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