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