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