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 <linux/namei.h>
  39#include <linux/random.h>
  40#include <net/ipv6.h>
  41#include "cifsfs.h"
  42#include "cifspdu.h"
  43#define DECLARE_GLOBALS_HERE
  44#include "cifsglob.h"
  45#include "cifsproto.h"
  46#include "cifs_debug.h"
  47#include "cifs_fs_sb.h"
  48#include <linux/mm.h>
  49#include <linux/key-type.h>
  50#include "cifs_spnego.h"
  51#include "fscache.h"
  52#ifdef CONFIG_CIFS_SMB2
  53#include "smb2pdu.h"
  54#endif
  55
  56int cifsFYI = 0;
  57int traceSMB = 0;
  58bool enable_oplocks = true;
  59unsigned int linuxExtEnabled = 1;
  60unsigned int lookupCacheEnabled = 1;
  61unsigned int global_secflags = CIFSSEC_DEF;
  62/* unsigned int ntlmv2_support = 0; */
  63unsigned int sign_CIFS_PDUs = 1;
  64static const struct super_operations cifs_super_ops;
  65unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  66module_param(CIFSMaxBufSize, uint, 0);
  67MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
  68                                 "Default: 16384 Range: 8192 to 130048");
  69unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  70module_param(cifs_min_rcv, uint, 0);
  71MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  72                                "1 to 64");
  73unsigned int cifs_min_small = 30;
  74module_param(cifs_min_small, uint, 0);
  75MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  76                                 "Range: 2 to 256");
  77unsigned int cifs_max_pending = CIFS_MAX_REQ;
  78module_param(cifs_max_pending, uint, 0444);
  79MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
  80                                   "Default: 32767 Range: 2 to 32767.");
  81module_param(enable_oplocks, bool, 0644);
  82MODULE_PARM_DESC(enable_oplocks, "Enable or disable oplocks. Default: y/Y/1");
  83
  84extern mempool_t *cifs_sm_req_poolp;
  85extern mempool_t *cifs_req_poolp;
  86extern mempool_t *cifs_mid_poolp;
  87
  88struct workqueue_struct *cifsiod_wq;
  89
  90/*
  91 * Bumps refcount for cifs super block.
  92 * Note that it should be only called if a referece to VFS super block is
  93 * already held, e.g. in open-type syscalls context. Otherwise it can race with
  94 * atomic_dec_and_test in deactivate_locked_super.
  95 */
  96void
  97cifs_sb_active(struct super_block *sb)
  98{
  99        struct cifs_sb_info *server = CIFS_SB(sb);
 100
 101        if (atomic_inc_return(&server->active) == 1)
 102                atomic_inc(&sb->s_active);
 103}
 104
 105void
 106cifs_sb_deactive(struct super_block *sb)
 107{
 108        struct cifs_sb_info *server = CIFS_SB(sb);
 109
 110        if (atomic_dec_and_test(&server->active))
 111                deactivate_super(sb);
 112}
 113
 114static int
 115cifs_read_super(struct super_block *sb)
 116{
 117        struct inode *inode;
 118        struct cifs_sb_info *cifs_sb;
 119        struct cifs_tcon *tcon;
 120        int rc = 0;
 121
 122        cifs_sb = CIFS_SB(sb);
 123        tcon = cifs_sb_master_tcon(cifs_sb);
 124
 125        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
 126                sb->s_flags |= MS_POSIXACL;
 127
 128        if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files)
 129                sb->s_maxbytes = MAX_LFS_FILESIZE;
 130        else
 131                sb->s_maxbytes = MAX_NON_LFS;
 132
 133        /* BB FIXME fix time_gran to be larger for LANMAN sessions */
 134        sb->s_time_gran = 100;
 135
 136        sb->s_magic = CIFS_MAGIC_NUMBER;
 137        sb->s_op = &cifs_super_ops;
 138        sb->s_bdi = &cifs_sb->bdi;
 139        sb->s_blocksize = CIFS_MAX_MSGSIZE;
 140        sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 141        inode = cifs_root_iget(sb);
 142
 143        if (IS_ERR(inode)) {
 144                rc = PTR_ERR(inode);
 145                goto out_no_root;
 146        }
 147
 148        if (tcon->nocase)
 149                sb->s_d_op = &cifs_ci_dentry_ops;
 150        else
 151                sb->s_d_op = &cifs_dentry_ops;
 152
 153        sb->s_root = d_make_root(inode);
 154        if (!sb->s_root) {
 155                rc = -ENOMEM;
 156                goto out_no_root;
 157        }
 158
 159#ifdef CONFIG_CIFS_NFSD_EXPORT
 160        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 161                cifs_dbg(FYI, "export ops supported\n");
 162                sb->s_export_op = &cifs_export_ops;
 163        }
 164#endif /* CONFIG_CIFS_NFSD_EXPORT */
 165
 166        return 0;
 167
 168out_no_root:
 169        cifs_dbg(VFS, "%s: get root inode failed\n", __func__);
 170        return rc;
 171}
 172
 173static void cifs_kill_sb(struct super_block *sb)
 174{
 175        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 176        kill_anon_super(sb);
 177        cifs_umount(cifs_sb);
 178}
 179
 180static int
 181cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 182{
 183        struct super_block *sb = dentry->d_sb;
 184        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 185        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 186        struct TCP_Server_Info *server = tcon->ses->server;
 187        unsigned int xid;
 188        int rc = 0;
 189
 190        xid = get_xid();
 191
 192        /*
 193         * PATH_MAX may be too long - it would presumably be total path,
 194         * but note that some servers (includinng Samba 3) have a shorter
 195         * maximum path.
 196         *
 197         * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
 198         */
 199        buf->f_namelen = PATH_MAX;
 200        buf->f_files = 0;       /* undefined */
 201        buf->f_ffree = 0;       /* unlimited */
 202
 203        if (server->ops->queryfs)
 204                rc = server->ops->queryfs(xid, tcon, buf);
 205
 206        free_xid(xid);
 207        return 0;
 208}
 209
 210static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 211{
 212        struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
 213        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 214        struct TCP_Server_Info *server = tcon->ses->server;
 215
 216        if (server->ops->fallocate)
 217                return server->ops->fallocate(file, tcon, mode, off, len);
 218
 219        return -EOPNOTSUPP;
 220}
 221
 222static int cifs_permission(struct inode *inode, int mask)
 223{
 224        struct cifs_sb_info *cifs_sb;
 225
 226        cifs_sb = CIFS_SB(inode->i_sb);
 227
 228        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 229                if ((mask & MAY_EXEC) && !execute_ok(inode))
 230                        return -EACCES;
 231                else
 232                        return 0;
 233        } else /* file mode might have been restricted at mount time
 234                on the client (above and beyond ACL on servers) for
 235                servers which do not support setting and viewing mode bits,
 236                so allowing client to check permissions is useful */
 237                return generic_permission(inode, mask);
 238}
 239
 240static struct kmem_cache *cifs_inode_cachep;
 241static struct kmem_cache *cifs_req_cachep;
 242static struct kmem_cache *cifs_mid_cachep;
 243static struct kmem_cache *cifs_sm_req_cachep;
 244mempool_t *cifs_sm_req_poolp;
 245mempool_t *cifs_req_poolp;
 246mempool_t *cifs_mid_poolp;
 247
 248static struct inode *
 249cifs_alloc_inode(struct super_block *sb)
 250{
 251        struct cifsInodeInfo *cifs_inode;
 252        cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 253        if (!cifs_inode)
 254                return NULL;
 255        cifs_inode->cifsAttrs = 0x20;   /* default */
 256        cifs_inode->time = 0;
 257        /*
 258         * Until the file is open and we have gotten oplock info back from the
 259         * server, can not assume caching of file data or metadata.
 260         */
 261        cifs_set_oplock_level(cifs_inode, 0);
 262        cifs_inode->flags = 0;
 263        spin_lock_init(&cifs_inode->writers_lock);
 264        cifs_inode->writers = 0;
 265        cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 266        cifs_inode->server_eof = 0;
 267        cifs_inode->uniqueid = 0;
 268        cifs_inode->createtime = 0;
 269        cifs_inode->epoch = 0;
 270#ifdef CONFIG_CIFS_SMB2
 271        get_random_bytes(cifs_inode->lease_key, SMB2_LEASE_KEY_SIZE);
 272#endif
 273        /*
 274         * Can not set i_flags here - they get immediately overwritten to zero
 275         * by the VFS.
 276         */
 277        /* cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME; */
 278        INIT_LIST_HEAD(&cifs_inode->openFileList);
 279        INIT_LIST_HEAD(&cifs_inode->llist);
 280        return &cifs_inode->vfs_inode;
 281}
 282
 283static void cifs_i_callback(struct rcu_head *head)
 284{
 285        struct inode *inode = container_of(head, struct inode, i_rcu);
 286        kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 287}
 288
 289static void
 290cifs_destroy_inode(struct inode *inode)
 291{
 292        call_rcu(&inode->i_rcu, cifs_i_callback);
 293}
 294
 295static void
 296cifs_evict_inode(struct inode *inode)
 297{
 298        truncate_inode_pages_final(&inode->i_data);
 299        clear_inode(inode);
 300        cifs_fscache_release_inode_cookie(inode);
 301}
 302
 303static void
 304cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 305{
 306        struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
 307        struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
 308
 309        seq_puts(s, ",addr=");
 310
 311        switch (server->dstaddr.ss_family) {
 312        case AF_INET:
 313                seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
 314                break;
 315        case AF_INET6:
 316                seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
 317                if (sa6->sin6_scope_id)
 318                        seq_printf(s, "%%%u", sa6->sin6_scope_id);
 319                break;
 320        default:
 321                seq_puts(s, "(unknown)");
 322        }
 323}
 324
 325static void
 326cifs_show_security(struct seq_file *s, struct cifs_ses *ses)
 327{
 328        if (ses->sectype == Unspecified)
 329                return;
 330
 331        seq_puts(s, ",sec=");
 332
 333        switch (ses->sectype) {
 334        case LANMAN:
 335                seq_puts(s, "lanman");
 336                break;
 337        case NTLMv2:
 338                seq_puts(s, "ntlmv2");
 339                break;
 340        case NTLM:
 341                seq_puts(s, "ntlm");
 342                break;
 343        case Kerberos:
 344                seq_puts(s, "krb5");
 345                break;
 346        case RawNTLMSSP:
 347                seq_puts(s, "ntlmssp");
 348                break;
 349        default:
 350                /* shouldn't ever happen */
 351                seq_puts(s, "unknown");
 352                break;
 353        }
 354
 355        if (ses->sign)
 356                seq_puts(s, "i");
 357}
 358
 359static void
 360cifs_show_cache_flavor(struct seq_file *s, struct cifs_sb_info *cifs_sb)
 361{
 362        seq_puts(s, ",cache=");
 363
 364        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 365                seq_puts(s, "strict");
 366        else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
 367                seq_puts(s, "none");
 368        else
 369                seq_puts(s, "loose");
 370}
 371
 372static void
 373cifs_show_nls(struct seq_file *s, struct nls_table *cur)
 374{
 375        struct nls_table *def;
 376
 377        /* Display iocharset= option if it's not default charset */
 378        def = load_nls_default();
 379        if (def != cur)
 380                seq_printf(s, ",iocharset=%s", cur->charset);
 381        unload_nls(def);
 382}
 383
 384/*
 385 * cifs_show_options() is for displaying mount options in /proc/mounts.
 386 * Not all settable options are displayed but most of the important
 387 * ones are.
 388 */
 389static int
 390cifs_show_options(struct seq_file *s, struct dentry *root)
 391{
 392        struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 393        struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 394        struct sockaddr *srcaddr;
 395        srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
 396
 397        seq_printf(s, ",vers=%s", tcon->ses->server->vals->version_string);
 398        cifs_show_security(s, tcon->ses);
 399        cifs_show_cache_flavor(s, cifs_sb);
 400
 401        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
 402                seq_puts(s, ",multiuser");
 403        else if (tcon->ses->user_name)
 404                seq_printf(s, ",username=%s", tcon->ses->user_name);
 405
 406        if (tcon->ses->domainName)
 407                seq_printf(s, ",domain=%s", tcon->ses->domainName);
 408
 409        if (srcaddr->sa_family != AF_UNSPEC) {
 410                struct sockaddr_in *saddr4;
 411                struct sockaddr_in6 *saddr6;
 412                saddr4 = (struct sockaddr_in *)srcaddr;
 413                saddr6 = (struct sockaddr_in6 *)srcaddr;
 414                if (srcaddr->sa_family == AF_INET6)
 415                        seq_printf(s, ",srcaddr=%pI6c",
 416                                   &saddr6->sin6_addr);
 417                else if (srcaddr->sa_family == AF_INET)
 418                        seq_printf(s, ",srcaddr=%pI4",
 419                                   &saddr4->sin_addr.s_addr);
 420                else
 421                        seq_printf(s, ",srcaddr=BAD-AF:%i",
 422                                   (int)(srcaddr->sa_family));
 423        }
 424
 425        seq_printf(s, ",uid=%u",
 426                   from_kuid_munged(&init_user_ns, cifs_sb->mnt_uid));
 427        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
 428                seq_puts(s, ",forceuid");
 429        else
 430                seq_puts(s, ",noforceuid");
 431
 432        seq_printf(s, ",gid=%u",
 433                   from_kgid_munged(&init_user_ns, cifs_sb->mnt_gid));
 434        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
 435                seq_puts(s, ",forcegid");
 436        else
 437                seq_puts(s, ",noforcegid");
 438
 439        cifs_show_address(s, tcon->ses->server);
 440
 441        if (!tcon->unix_ext)
 442                seq_printf(s, ",file_mode=0%ho,dir_mode=0%ho",
 443                                           cifs_sb->mnt_file_mode,
 444                                           cifs_sb->mnt_dir_mode);
 445
 446        cifs_show_nls(s, cifs_sb->local_nls);
 447
 448        if (tcon->seal)
 449                seq_puts(s, ",seal");
 450        if (tcon->nocase)
 451                seq_puts(s, ",nocase");
 452        if (tcon->retry)
 453                seq_puts(s, ",hard");
 454        if (tcon->unix_ext)
 455                seq_puts(s, ",unix");
 456        else
 457                seq_puts(s, ",nounix");
 458        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
 459                seq_puts(s, ",posixpaths");
 460        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
 461                seq_puts(s, ",setuids");
 462        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 463                seq_puts(s, ",serverino");
 464        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 465                seq_puts(s, ",rwpidforward");
 466        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
 467                seq_puts(s, ",forcemand");
 468        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 469                seq_puts(s, ",nouser_xattr");
 470        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 471                seq_puts(s, ",mapchars");
 472        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 473                seq_puts(s, ",sfu");
 474        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 475                seq_puts(s, ",nobrl");
 476        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
 477                seq_puts(s, ",cifsacl");
 478        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 479                seq_puts(s, ",dynperm");
 480        if (root->d_sb->s_flags & MS_POSIXACL)
 481                seq_puts(s, ",acl");
 482        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
 483                seq_puts(s, ",mfsymlinks");
 484        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
 485                seq_puts(s, ",fsc");
 486        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)
 487                seq_puts(s, ",nostrictsync");
 488        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
 489                seq_puts(s, ",noperm");
 490        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID)
 491                seq_printf(s, ",backupuid=%u",
 492                           from_kuid_munged(&init_user_ns,
 493                                            cifs_sb->mnt_backupuid));
 494        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID)
 495                seq_printf(s, ",backupgid=%u",
 496                           from_kgid_munged(&init_user_ns,
 497                                            cifs_sb->mnt_backupgid));
 498
 499        seq_printf(s, ",rsize=%u", cifs_sb->rsize);
 500        seq_printf(s, ",wsize=%u", cifs_sb->wsize);
 501        /* convert actimeo and display it in seconds */
 502        seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
 503
 504        return 0;
 505}
 506
 507static void cifs_umount_begin(struct super_block *sb)
 508{
 509        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 510        struct cifs_tcon *tcon;
 511
 512        if (cifs_sb == NULL)
 513                return;
 514
 515        tcon = cifs_sb_master_tcon(cifs_sb);
 516
 517        spin_lock(&cifs_tcp_ses_lock);
 518        if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 519                /* we have other mounts to same share or we have
 520                   already tried to force umount this and woken up
 521                   all waiting network requests, nothing to do */
 522                spin_unlock(&cifs_tcp_ses_lock);
 523                return;
 524        } else if (tcon->tc_count == 1)
 525                tcon->tidStatus = CifsExiting;
 526        spin_unlock(&cifs_tcp_ses_lock);
 527
 528        /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 529        /* cancel_notify_requests(tcon); */
 530        if (tcon->ses && tcon->ses->server) {
 531                cifs_dbg(FYI, "wake up tasks now - umount begin not complete\n");
 532                wake_up_all(&tcon->ses->server->request_q);
 533                wake_up_all(&tcon->ses->server->response_q);
 534                msleep(1); /* yield */
 535                /* we have to kick the requests once more */
 536                wake_up_all(&tcon->ses->server->response_q);
 537                msleep(1);
 538        }
 539
 540        return;
 541}
 542
 543#ifdef CONFIG_CIFS_STATS2
 544static int cifs_show_stats(struct seq_file *s, struct dentry *root)
 545{
 546        /* BB FIXME */
 547        return 0;
 548}
 549#endif
 550
 551static int cifs_remount(struct super_block *sb, int *flags, char *data)
 552{
 553        sync_filesystem(sb);
 554        *flags |= MS_NODIRATIME;
 555        return 0;
 556}
 557
 558static int cifs_drop_inode(struct inode *inode)
 559{
 560        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 561
 562        /* no serverino => unconditional eviction */
 563        return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
 564                generic_drop_inode(inode);
 565}
 566
 567static const struct super_operations cifs_super_ops = {
 568        .statfs = cifs_statfs,
 569        .alloc_inode = cifs_alloc_inode,
 570        .destroy_inode = cifs_destroy_inode,
 571        .drop_inode     = cifs_drop_inode,
 572        .evict_inode    = cifs_evict_inode,
 573/*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
 574        function unless later we add lazy close of inodes or unless the
 575        kernel forgets to call us with the same number of releases (closes)
 576        as opens */
 577        .show_options = cifs_show_options,
 578        .umount_begin   = cifs_umount_begin,
 579        .remount_fs = cifs_remount,
 580#ifdef CONFIG_CIFS_STATS2
 581        .show_stats = cifs_show_stats,
 582#endif
 583};
 584
 585/*
 586 * Get root dentry from superblock according to prefix path mount option.
 587 * Return dentry with refcount + 1 on success and NULL otherwise.
 588 */
 589static struct dentry *
 590cifs_get_root(struct smb_vol *vol, struct super_block *sb)
 591{
 592        struct dentry *dentry;
 593        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 594        char *full_path = NULL;
 595        char *s, *p;
 596        char sep;
 597
 598        full_path = cifs_build_path_to_root(vol, cifs_sb,
 599                                            cifs_sb_master_tcon(cifs_sb));
 600        if (full_path == NULL)
 601                return ERR_PTR(-ENOMEM);
 602
 603        cifs_dbg(FYI, "Get root dentry for %s\n", full_path);
 604
 605        sep = CIFS_DIR_SEP(cifs_sb);
 606        dentry = dget(sb->s_root);
 607        p = s = full_path;
 608
 609        do {
 610                struct inode *dir = dentry->d_inode;
 611                struct dentry *child;
 612
 613                if (!dir) {
 614                        dput(dentry);
 615                        dentry = ERR_PTR(-ENOENT);
 616                        break;
 617                }
 618                if (!S_ISDIR(dir->i_mode)) {
 619                        dput(dentry);
 620                        dentry = ERR_PTR(-ENOTDIR);
 621                        break;
 622                }
 623
 624                /* skip separators */
 625                while (*s == sep)
 626                        s++;
 627                if (!*s)
 628                        break;
 629                p = s++;
 630                /* next separator */
 631                while (*s && *s != sep)
 632                        s++;
 633
 634                mutex_lock(&dir->i_mutex);
 635                child = lookup_one_len(p, dentry, s - p);
 636                mutex_unlock(&dir->i_mutex);
 637                dput(dentry);
 638                dentry = child;
 639        } while (!IS_ERR(dentry));
 640        kfree(full_path);
 641        return dentry;
 642}
 643
 644static int cifs_set_super(struct super_block *sb, void *data)
 645{
 646        struct cifs_mnt_data *mnt_data = data;
 647        sb->s_fs_info = mnt_data->cifs_sb;
 648        return set_anon_super(sb, NULL);
 649}
 650
 651static struct dentry *
 652cifs_do_mount(struct file_system_type *fs_type,
 653              int flags, const char *dev_name, void *data)
 654{
 655        int rc;
 656        struct super_block *sb;
 657        struct cifs_sb_info *cifs_sb;
 658        struct smb_vol *volume_info;
 659        struct cifs_mnt_data mnt_data;
 660        struct dentry *root;
 661
 662        cifs_dbg(FYI, "Devname: %s flags: %d\n", dev_name, flags);
 663
 664        volume_info = cifs_get_volume_info((char *)data, dev_name);
 665        if (IS_ERR(volume_info))
 666                return ERR_CAST(volume_info);
 667
 668        cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 669        if (cifs_sb == NULL) {
 670                root = ERR_PTR(-ENOMEM);
 671                goto out_nls;
 672        }
 673
 674        cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
 675        if (cifs_sb->mountdata == NULL) {
 676                root = ERR_PTR(-ENOMEM);
 677                goto out_cifs_sb;
 678        }
 679
 680        cifs_setup_cifs_sb(volume_info, cifs_sb);
 681
 682        rc = cifs_mount(cifs_sb, volume_info);
 683        if (rc) {
 684                if (!(flags & MS_SILENT))
 685                        cifs_dbg(VFS, "cifs_mount failed w/return code = %d\n",
 686                                 rc);
 687                root = ERR_PTR(rc);
 688                goto out_mountdata;
 689        }
 690
 691        mnt_data.vol = volume_info;
 692        mnt_data.cifs_sb = cifs_sb;
 693        mnt_data.flags = flags;
 694
 695        /* BB should we make this contingent on mount parm? */
 696        flags |= MS_NODIRATIME | MS_NOATIME;
 697
 698        sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
 699        if (IS_ERR(sb)) {
 700                root = ERR_CAST(sb);
 701                cifs_umount(cifs_sb);
 702                goto out;
 703        }
 704
 705        if (sb->s_root) {
 706                cifs_dbg(FYI, "Use existing superblock\n");
 707                cifs_umount(cifs_sb);
 708        } else {
 709                rc = cifs_read_super(sb);
 710                if (rc) {
 711                        root = ERR_PTR(rc);
 712                        goto out_super;
 713                }
 714
 715                sb->s_flags |= MS_ACTIVE;
 716        }
 717
 718        root = cifs_get_root(volume_info, sb);
 719        if (IS_ERR(root))
 720                goto out_super;
 721
 722        cifs_dbg(FYI, "dentry root is: %p\n", root);
 723        goto out;
 724
 725out_super:
 726        deactivate_locked_super(sb);
 727out:
 728        cifs_cleanup_volume_info(volume_info);
 729        return root;
 730
 731out_mountdata:
 732        kfree(cifs_sb->mountdata);
 733out_cifs_sb:
 734        kfree(cifs_sb);
 735out_nls:
 736        unload_nls(volume_info->local_nls);
 737        goto out;
 738}
 739
 740static ssize_t
 741cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 742{
 743        ssize_t rc;
 744        struct inode *inode = file_inode(iocb->ki_filp);
 745
 746        rc = cifs_revalidate_mapping(inode);
 747        if (rc)
 748                return rc;
 749
 750        return generic_file_read_iter(iocb, iter);
 751}
 752
 753static ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 754{
 755        struct inode *inode = file_inode(iocb->ki_filp);
 756        struct cifsInodeInfo *cinode = CIFS_I(inode);
 757        ssize_t written;
 758        int rc;
 759
 760        written = cifs_get_writer(cinode);
 761        if (written)
 762                return written;
 763
 764        written = generic_file_write_iter(iocb, from);
 765
 766        if (CIFS_CACHE_WRITE(CIFS_I(inode)))
 767                goto out;
 768
 769        rc = filemap_fdatawrite(inode->i_mapping);
 770        if (rc)
 771                cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
 772                         rc, inode);
 773
 774out:
 775        cifs_put_writer(cinode);
 776        return written;
 777}
 778
 779static loff_t cifs_llseek(struct file *file, loff_t offset, int whence)
 780{
 781        /*
 782         * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
 783         * the cached file length
 784         */
 785        if (whence != SEEK_SET && whence != SEEK_CUR) {
 786                int rc;
 787                struct inode *inode = file_inode(file);
 788
 789                /*
 790                 * We need to be sure that all dirty pages are written and the
 791                 * server has the newest file length.
 792                 */
 793                if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
 794                    inode->i_mapping->nrpages != 0) {
 795                        rc = filemap_fdatawait(inode->i_mapping);
 796                        if (rc) {
 797                                mapping_set_error(inode->i_mapping, rc);
 798                                return rc;
 799                        }
 800                }
 801                /*
 802                 * Some applications poll for the file length in this strange
 803                 * way so we must seek to end on non-oplocked files by
 804                 * setting the revalidate time to zero.
 805                 */
 806                CIFS_I(inode)->time = 0;
 807
 808                rc = cifs_revalidate_file_attr(file);
 809                if (rc < 0)
 810                        return (loff_t)rc;
 811        }
 812        return generic_file_llseek(file, offset, whence);
 813}
 814
 815static int
 816cifs_setlease(struct file *file, long arg, struct file_lock **lease, void **priv)
 817{
 818        /*
 819         * Note that this is called by vfs setlease with i_lock held to
 820         * protect *lease from going away.
 821         */
 822        struct inode *inode = file_inode(file);
 823        struct cifsFileInfo *cfile = file->private_data;
 824
 825        if (!(S_ISREG(inode->i_mode)))
 826                return -EINVAL;
 827
 828        /* Check if file is oplocked if this is request for new lease */
 829        if (arg == F_UNLCK ||
 830            ((arg == F_RDLCK) && CIFS_CACHE_READ(CIFS_I(inode))) ||
 831            ((arg == F_WRLCK) && CIFS_CACHE_WRITE(CIFS_I(inode))))
 832                return generic_setlease(file, arg, lease, priv);
 833        else if (tlink_tcon(cfile->tlink)->local_lease &&
 834                 !CIFS_CACHE_READ(CIFS_I(inode)))
 835                /*
 836                 * If the server claims to support oplock on this file, then we
 837                 * still need to check oplock even if the local_lease mount
 838                 * option is set, but there are servers which do not support
 839                 * oplock for which this mount option may be useful if the user
 840                 * knows that the file won't be changed on the server by anyone
 841                 * else.
 842                 */
 843                return generic_setlease(file, arg, lease, priv);
 844        else
 845                return -EAGAIN;
 846}
 847
 848struct file_system_type cifs_fs_type = {
 849        .owner = THIS_MODULE,
 850        .name = "cifs",
 851        .mount = cifs_do_mount,
 852        .kill_sb = cifs_kill_sb,
 853        /*  .fs_flags */
 854};
 855MODULE_ALIAS_FS("cifs");
 856const struct inode_operations cifs_dir_inode_ops = {
 857        .create = cifs_create,
 858        .atomic_open = cifs_atomic_open,
 859        .lookup = cifs_lookup,
 860        .getattr = cifs_getattr,
 861        .unlink = cifs_unlink,
 862        .link = cifs_hardlink,
 863        .mkdir = cifs_mkdir,
 864        .rmdir = cifs_rmdir,
 865        .rename2 = cifs_rename2,
 866        .permission = cifs_permission,
 867/*      revalidate:cifs_revalidate,   */
 868        .setattr = cifs_setattr,
 869        .symlink = cifs_symlink,
 870        .mknod   = cifs_mknod,
 871#ifdef CONFIG_CIFS_XATTR
 872        .setxattr = cifs_setxattr,
 873        .getxattr = cifs_getxattr,
 874        .listxattr = cifs_listxattr,
 875        .removexattr = cifs_removexattr,
 876#endif
 877};
 878
 879const struct inode_operations cifs_file_inode_ops = {
 880/*      revalidate:cifs_revalidate, */
 881        .setattr = cifs_setattr,
 882        .getattr = cifs_getattr, /* do we need this anymore? */
 883        .permission = cifs_permission,
 884#ifdef CONFIG_CIFS_XATTR
 885        .setxattr = cifs_setxattr,
 886        .getxattr = cifs_getxattr,
 887        .listxattr = cifs_listxattr,
 888        .removexattr = cifs_removexattr,
 889#endif
 890};
 891
 892const struct inode_operations cifs_symlink_inode_ops = {
 893        .readlink = generic_readlink,
 894        .follow_link = cifs_follow_link,
 895        .put_link = kfree_put_link,
 896        .permission = cifs_permission,
 897        /* BB add the following two eventually */
 898        /* revalidate: cifs_revalidate,
 899           setattr:    cifs_notify_change, *//* BB do we need notify change */
 900#ifdef CONFIG_CIFS_XATTR
 901        .setxattr = cifs_setxattr,
 902        .getxattr = cifs_getxattr,
 903        .listxattr = cifs_listxattr,
 904        .removexattr = cifs_removexattr,
 905#endif
 906};
 907
 908const struct file_operations cifs_file_ops = {
 909        .read = new_sync_read,
 910        .write = new_sync_write,
 911        .read_iter = cifs_loose_read_iter,
 912        .write_iter = cifs_file_write_iter,
 913        .open = cifs_open,
 914        .release = cifs_close,
 915        .lock = cifs_lock,
 916        .fsync = cifs_fsync,
 917        .flush = cifs_flush,
 918        .mmap  = cifs_file_mmap,
 919        .splice_read = generic_file_splice_read,
 920        .llseek = cifs_llseek,
 921#ifdef CONFIG_CIFS_POSIX
 922        .unlocked_ioctl = cifs_ioctl,
 923#endif /* CONFIG_CIFS_POSIX */
 924        .setlease = cifs_setlease,
 925        .fallocate = cifs_fallocate,
 926};
 927
 928const struct file_operations cifs_file_strict_ops = {
 929        .read = new_sync_read,
 930        .write = new_sync_write,
 931        .read_iter = cifs_strict_readv,
 932        .write_iter = cifs_strict_writev,
 933        .open = cifs_open,
 934        .release = cifs_close,
 935        .lock = cifs_lock,
 936        .fsync = cifs_strict_fsync,
 937        .flush = cifs_flush,
 938        .mmap = cifs_file_strict_mmap,
 939        .splice_read = generic_file_splice_read,
 940        .llseek = cifs_llseek,
 941#ifdef CONFIG_CIFS_POSIX
 942        .unlocked_ioctl = cifs_ioctl,
 943#endif /* CONFIG_CIFS_POSIX */
 944        .setlease = cifs_setlease,
 945        .fallocate = cifs_fallocate,
 946};
 947
 948const struct file_operations cifs_file_direct_ops = {
 949        /* BB reevaluate whether they can be done with directio, no cache */
 950        .read = new_sync_read,
 951        .write = new_sync_write,
 952        .read_iter = cifs_user_readv,
 953        .write_iter = cifs_user_writev,
 954        .open = cifs_open,
 955        .release = cifs_close,
 956        .lock = cifs_lock,
 957        .fsync = cifs_fsync,
 958        .flush = cifs_flush,
 959        .mmap = cifs_file_mmap,
 960        .splice_read = generic_file_splice_read,
 961#ifdef CONFIG_CIFS_POSIX
 962        .unlocked_ioctl  = cifs_ioctl,
 963#endif /* CONFIG_CIFS_POSIX */
 964        .llseek = cifs_llseek,
 965        .setlease = cifs_setlease,
 966        .fallocate = cifs_fallocate,
 967};
 968
 969const struct file_operations cifs_file_nobrl_ops = {
 970        .read = new_sync_read,
 971        .write = new_sync_write,
 972        .read_iter = cifs_loose_read_iter,
 973        .write_iter = cifs_file_write_iter,
 974        .open = cifs_open,
 975        .release = cifs_close,
 976        .fsync = cifs_fsync,
 977        .flush = cifs_flush,
 978        .mmap  = cifs_file_mmap,
 979        .splice_read = generic_file_splice_read,
 980        .llseek = cifs_llseek,
 981#ifdef CONFIG_CIFS_POSIX
 982        .unlocked_ioctl = cifs_ioctl,
 983#endif /* CONFIG_CIFS_POSIX */
 984        .setlease = cifs_setlease,
 985        .fallocate = cifs_fallocate,
 986};
 987
 988const struct file_operations cifs_file_strict_nobrl_ops = {
 989        .read = new_sync_read,
 990        .write = new_sync_write,
 991        .read_iter = cifs_strict_readv,
 992        .write_iter = cifs_strict_writev,
 993        .open = cifs_open,
 994        .release = cifs_close,
 995        .fsync = cifs_strict_fsync,
 996        .flush = cifs_flush,
 997        .mmap = cifs_file_strict_mmap,
 998        .splice_read = generic_file_splice_read,
 999        .llseek = cifs_llseek,
1000#ifdef CONFIG_CIFS_POSIX
1001        .unlocked_ioctl = cifs_ioctl,
1002#endif /* CONFIG_CIFS_POSIX */
1003        .setlease = cifs_setlease,
1004        .fallocate = cifs_fallocate,
1005};
1006
1007const struct file_operations cifs_file_direct_nobrl_ops = {
1008        /* BB reevaluate whether they can be done with directio, no cache */
1009        .read = new_sync_read,
1010        .write = new_sync_write,
1011        .read_iter = cifs_user_readv,
1012        .write_iter = cifs_user_writev,
1013        .open = cifs_open,
1014        .release = cifs_close,
1015        .fsync = cifs_fsync,
1016        .flush = cifs_flush,
1017        .mmap = cifs_file_mmap,
1018        .splice_read = generic_file_splice_read,
1019#ifdef CONFIG_CIFS_POSIX
1020        .unlocked_ioctl  = cifs_ioctl,
1021#endif /* CONFIG_CIFS_POSIX */
1022        .llseek = cifs_llseek,
1023        .setlease = cifs_setlease,
1024        .fallocate = cifs_fallocate,
1025};
1026
1027const struct file_operations cifs_dir_ops = {
1028        .iterate = cifs_readdir,
1029        .release = cifs_closedir,
1030        .read    = generic_read_dir,
1031        .unlocked_ioctl  = cifs_ioctl,
1032        .llseek = generic_file_llseek,
1033};
1034
1035static void
1036cifs_init_once(void *inode)
1037{
1038        struct cifsInodeInfo *cifsi = inode;
1039
1040        inode_init_once(&cifsi->vfs_inode);
1041        init_rwsem(&cifsi->lock_sem);
1042}
1043
1044static int __init
1045cifs_init_inodecache(void)
1046{
1047        cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1048                                              sizeof(struct cifsInodeInfo),
1049                                              0, (SLAB_RECLAIM_ACCOUNT|
1050                                                SLAB_MEM_SPREAD),
1051                                              cifs_init_once);
1052        if (cifs_inode_cachep == NULL)
1053                return -ENOMEM;
1054
1055        return 0;
1056}
1057
1058static void
1059cifs_destroy_inodecache(void)
1060{
1061        /*
1062         * Make sure all delayed rcu free inodes are flushed before we
1063         * destroy cache.
1064         */
1065        rcu_barrier();
1066        kmem_cache_destroy(cifs_inode_cachep);
1067}
1068
1069static int
1070cifs_init_request_bufs(void)
1071{
1072        size_t max_hdr_size = MAX_CIFS_HDR_SIZE;
1073#ifdef CONFIG_CIFS_SMB2
1074        /*
1075         * SMB2 maximum header size is bigger than CIFS one - no problems to
1076         * allocate some more bytes for CIFS.
1077         */
1078        max_hdr_size = MAX_SMB2_HDR_SIZE;
1079#endif
1080        if (CIFSMaxBufSize < 8192) {
1081        /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1082        Unicode path name has to fit in any SMB/CIFS path based frames */
1083                CIFSMaxBufSize = 8192;
1084        } else if (CIFSMaxBufSize > 1024*127) {
1085                CIFSMaxBufSize = 1024 * 127;
1086        } else {
1087                CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1088        }
1089/*
1090        cifs_dbg(VFS, "CIFSMaxBufSize %d 0x%x\n",
1091                 CIFSMaxBufSize, CIFSMaxBufSize);
1092*/
1093        cifs_req_cachep = kmem_cache_create("cifs_request",
1094                                            CIFSMaxBufSize + max_hdr_size, 0,
1095                                            SLAB_HWCACHE_ALIGN, NULL);
1096        if (cifs_req_cachep == NULL)
1097                return -ENOMEM;
1098
1099        if (cifs_min_rcv < 1)
1100                cifs_min_rcv = 1;
1101        else if (cifs_min_rcv > 64) {
1102                cifs_min_rcv = 64;
1103                cifs_dbg(VFS, "cifs_min_rcv set to maximum (64)\n");
1104        }
1105
1106        cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1107                                                  cifs_req_cachep);
1108
1109        if (cifs_req_poolp == NULL) {
1110                kmem_cache_destroy(cifs_req_cachep);
1111                return -ENOMEM;
1112        }
1113        /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1114        almost all handle based requests (but not write response, nor is it
1115        sufficient for path based requests).  A smaller size would have
1116        been more efficient (compacting multiple slab items on one 4k page)
1117        for the case in which debug was on, but this larger size allows
1118        more SMBs to use small buffer alloc and is still much more
1119        efficient to alloc 1 per page off the slab compared to 17K (5page)
1120        alloc of large cifs buffers even when page debugging is on */
1121        cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1122                        MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1123                        NULL);
1124        if (cifs_sm_req_cachep == NULL) {
1125                mempool_destroy(cifs_req_poolp);
1126                kmem_cache_destroy(cifs_req_cachep);
1127                return -ENOMEM;
1128        }
1129
1130        if (cifs_min_small < 2)
1131                cifs_min_small = 2;
1132        else if (cifs_min_small > 256) {
1133                cifs_min_small = 256;
1134                cifs_dbg(FYI, "cifs_min_small set to maximum (256)\n");
1135        }
1136
1137        cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1138                                                     cifs_sm_req_cachep);
1139
1140        if (cifs_sm_req_poolp == NULL) {
1141                mempool_destroy(cifs_req_poolp);
1142                kmem_cache_destroy(cifs_req_cachep);
1143                kmem_cache_destroy(cifs_sm_req_cachep);
1144                return -ENOMEM;
1145        }
1146
1147        return 0;
1148}
1149
1150static void
1151cifs_destroy_request_bufs(void)
1152{
1153        mempool_destroy(cifs_req_poolp);
1154        kmem_cache_destroy(cifs_req_cachep);
1155        mempool_destroy(cifs_sm_req_poolp);
1156        kmem_cache_destroy(cifs_sm_req_cachep);
1157}
1158
1159static int
1160cifs_init_mids(void)
1161{
1162        cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1163                                            sizeof(struct mid_q_entry), 0,
1164                                            SLAB_HWCACHE_ALIGN, NULL);
1165        if (cifs_mid_cachep == NULL)
1166                return -ENOMEM;
1167
1168        /* 3 is a reasonable minimum number of simultaneous operations */
1169        cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1170        if (cifs_mid_poolp == NULL) {
1171                kmem_cache_destroy(cifs_mid_cachep);
1172                return -ENOMEM;
1173        }
1174
1175        return 0;
1176}
1177
1178static void
1179cifs_destroy_mids(void)
1180{
1181        mempool_destroy(cifs_mid_poolp);
1182        kmem_cache_destroy(cifs_mid_cachep);
1183}
1184
1185static int __init
1186init_cifs(void)
1187{
1188        int rc = 0;
1189        cifs_proc_init();
1190        INIT_LIST_HEAD(&cifs_tcp_ses_list);
1191#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1192        INIT_LIST_HEAD(&GlobalDnotifyReqList);
1193        INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1194#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1195/*
1196 *  Initialize Global counters
1197 */
1198        atomic_set(&sesInfoAllocCount, 0);
1199        atomic_set(&tconInfoAllocCount, 0);
1200        atomic_set(&tcpSesAllocCount, 0);
1201        atomic_set(&tcpSesReconnectCount, 0);
1202        atomic_set(&tconInfoReconnectCount, 0);
1203
1204        atomic_set(&bufAllocCount, 0);
1205        atomic_set(&smBufAllocCount, 0);
1206#ifdef CONFIG_CIFS_STATS2
1207        atomic_set(&totBufAllocCount, 0);
1208        atomic_set(&totSmBufAllocCount, 0);
1209#endif /* CONFIG_CIFS_STATS2 */
1210
1211        atomic_set(&midCount, 0);
1212        GlobalCurrentXid = 0;
1213        GlobalTotalActiveXid = 0;
1214        GlobalMaxActiveXid = 0;
1215        spin_lock_init(&cifs_tcp_ses_lock);
1216        spin_lock_init(&cifs_file_list_lock);
1217        spin_lock_init(&GlobalMid_Lock);
1218
1219        if (cifs_max_pending < 2) {
1220                cifs_max_pending = 2;
1221                cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
1222        } else if (cifs_max_pending > CIFS_MAX_REQ) {
1223                cifs_max_pending = CIFS_MAX_REQ;
1224                cifs_dbg(FYI, "cifs_max_pending set to max of %u\n",
1225                         CIFS_MAX_REQ);
1226        }
1227
1228        cifsiod_wq = alloc_workqueue("cifsiod", WQ_FREEZABLE|WQ_MEM_RECLAIM, 0);
1229        if (!cifsiod_wq) {
1230                rc = -ENOMEM;
1231                goto out_clean_proc;
1232        }
1233
1234        rc = cifs_fscache_register();
1235        if (rc)
1236                goto out_destroy_wq;
1237
1238        rc = cifs_init_inodecache();
1239        if (rc)
1240                goto out_unreg_fscache;
1241
1242        rc = cifs_init_mids();
1243        if (rc)
1244                goto out_destroy_inodecache;
1245
1246        rc = cifs_init_request_bufs();
1247        if (rc)
1248                goto out_destroy_mids;
1249
1250#ifdef CONFIG_CIFS_UPCALL
1251        rc = register_key_type(&cifs_spnego_key_type);
1252        if (rc)
1253                goto out_destroy_request_bufs;
1254#endif /* CONFIG_CIFS_UPCALL */
1255
1256#ifdef CONFIG_CIFS_ACL
1257        rc = init_cifs_idmap();
1258        if (rc)
1259                goto out_register_key_type;
1260#endif /* CONFIG_CIFS_ACL */
1261
1262        rc = register_filesystem(&cifs_fs_type);
1263        if (rc)
1264                goto out_init_cifs_idmap;
1265
1266        return 0;
1267
1268out_init_cifs_idmap:
1269#ifdef CONFIG_CIFS_ACL
1270        exit_cifs_idmap();
1271out_register_key_type:
1272#endif
1273#ifdef CONFIG_CIFS_UPCALL
1274        unregister_key_type(&cifs_spnego_key_type);
1275out_destroy_request_bufs:
1276#endif
1277        cifs_destroy_request_bufs();
1278out_destroy_mids:
1279        cifs_destroy_mids();
1280out_destroy_inodecache:
1281        cifs_destroy_inodecache();
1282out_unreg_fscache:
1283        cifs_fscache_unregister();
1284out_destroy_wq:
1285        destroy_workqueue(cifsiod_wq);
1286out_clean_proc:
1287        cifs_proc_clean();
1288        return rc;
1289}
1290
1291static void __exit
1292exit_cifs(void)
1293{
1294        cifs_dbg(NOISY, "exit_cifs\n");
1295        unregister_filesystem(&cifs_fs_type);
1296        cifs_dfs_release_automount_timer();
1297#ifdef CONFIG_CIFS_ACL
1298        exit_cifs_idmap();
1299#endif
1300#ifdef CONFIG_CIFS_UPCALL
1301        unregister_key_type(&cifs_spnego_key_type);
1302#endif
1303        cifs_destroy_request_bufs();
1304        cifs_destroy_mids();
1305        cifs_destroy_inodecache();
1306        cifs_fscache_unregister();
1307        destroy_workqueue(cifsiod_wq);
1308        cifs_proc_clean();
1309}
1310
1311MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1312MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1313MODULE_DESCRIPTION
1314    ("VFS to access servers complying with the SNIA CIFS Specification "
1315     "e.g. Samba and Windows");
1316MODULE_VERSION(CIFS_VERSION);
1317module_init(init_cifs)
1318module_exit(exit_cifs)
1319
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.