Adding upstream version 6.1.22-dfsg.upstream/6.1.22-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1753 insertions, 0 deletions

diff --git a/src/VBox/Additions/linux/sharedfolders/vfsmod.c b/src/VBox/Additions/linux/sharedfolders/vfsmod.c
new file mode 100644
index 00000000..6167683a
--- /dev/null
+++ b/src/VBox/Additions/linux/sharedfolders/vfsmod.c
@@ -0,0 +1,1753 @@
+/* $Id: vfsmod.c $ */
+/** @file
+ * vboxsf - VBox Linux Shared Folders VFS, module init/term, super block management.
+ */
+
+/*
+ * Copyright (C) 2006-2020 Oracle Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * @note Anyone wishing to make changes here might wish to take a look at
+ * https://github.com/torvalds/linux/blob/master/Documentation/filesystems/vfs.txt
+ * which seems to be the closest there is to official documentation on
+ * writing filesystem drivers for Linux.
+ *
+ * See also: http://us1.samba.org/samba/ftp/cifs-cvs/ols2006-fs-tutorial-smf.odp
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "vfsmod.h"
+#include "version-generated.h"
+#include "revision-generated.h"
+#include "product-generated.h"
+#if RTLNX_VER_MIN(5,0,0) || RTLNX_RHEL_MIN(8,4)
+# include <uapi/linux/mount.h> /* for MS_REMOUNT */
+#elif RTLNX_VER_MAX(3,3,0)
+# include <linux/mount.h>
+#endif
+#include <linux/seq_file.h>
+#include <linux/vfs.h>
+#if RTLNX_VER_RANGE(2,5,62,  5,8,0)
+# include <linux/vermagic.h>
+#endif
+#include <VBox/err.h>
+#include <iprt/path.h>
+#if RTLNX_VER_MIN(5,1,0)
+# include <linux/fs_context.h>
+# include <linux/fs_parser.h>
+#elif RTLNX_VER_MIN(2,6,0)
+# include <linux/parser.h>
+#endif
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define VBSF_DEFAULT_MAX_IO_PAGES RT_MIN(_16K / sizeof(RTGCPHYS64) /* => 8MB buffer */, VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT)
+#define VBSF_DEFAULT_DIR_BUF_SIZE _64K
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+VBGLSFCLIENT g_SfClient;
+uint32_t     g_fHostFeatures = 0;
+/** Last valid shared folders function number. */
+uint32_t     g_uSfLastFunction = SHFL_FN_SET_FILE_SIZE;
+/** Shared folders features (SHFL_FEATURE_XXX). */
+uint64_t     g_fSfFeatures = 0;
+
+/** Protects all the vbsf_inode_info::HandleList lists. */
+spinlock_t   g_SfHandleLock;
+
+/** The 'follow_symlinks' module parameter.
+ * @todo Figure out how do this for 2.4.x! */
+static int   g_fFollowSymlinks = 0;
+
+/* forward declaration */
+static struct super_operations g_vbsf_super_ops;
+
+
+
+/**
+ * Copies options from the mount info structure into @a pSuperInfo.
+ *
+ * This is used both by vbsf_super_info_alloc_and_map_it() and
+ * vbsf_remount_fs().
+ */
+static void vbsf_super_info_copy_remount_options(struct vbsf_super_info *pSuperInfo, struct vbsf_mount_info_new *info)
+{
+    pSuperInfo->uid = info->uid;
+    pSuperInfo->gid = info->gid;
+
+    if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, szTag)) {
+        /* new fields */
+        pSuperInfo->dmode = info->dmode;
+        pSuperInfo->fmode = info->fmode;
+        pSuperInfo->dmask = info->dmask;
+        pSuperInfo->fmask = info->fmask;
+    } else {
+        pSuperInfo->dmode = ~0;
+        pSuperInfo->fmode = ~0;
+    }
+
+    if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, cMaxIoPages)) {
+        AssertCompile(sizeof(pSuperInfo->szTag) >= sizeof(info->szTag));
+        memcpy(pSuperInfo->szTag, info->szTag, sizeof(info->szTag));
+        pSuperInfo->szTag[sizeof(pSuperInfo->szTag) - 1] = '\0';
+    } else {
+        pSuperInfo->szTag[0] = '\0';
+    }
+
+    /* The max number of pages in an I/O request.  This must take into
+       account that the physical heap generally grows in 64 KB chunks,
+       so we should not try push that limit.   It also needs to take
+       into account that the host will allocate temporary heap buffers
+       for the I/O bytes we send/receive, so don't push the host heap
+       too hard as we'd have to retry with smaller requests when this
+       happens, which isn't too efficient. */
+    pSuperInfo->cMaxIoPages = VBSF_DEFAULT_MAX_IO_PAGES;
+    if (   (unsigned)info->length >= sizeof(struct vbsf_mount_info_new)
+        && info->cMaxIoPages > 0) {
+        if (info->cMaxIoPages <= VMMDEV_MAX_HGCM_DATA_SIZE >> PAGE_SHIFT)
+            pSuperInfo->cMaxIoPages = RT_MAX(info->cMaxIoPages, 2); /* read_iter/write_iter requires a minimum of 2. */
+        else
+            printk(KERN_WARNING "vboxsf: max I/O page count (%#x) is out of range, using default (%#x) instead.\n",
+                   info->cMaxIoPages, pSuperInfo->cMaxIoPages);
+    }
+
+    pSuperInfo->cbDirBuf = VBSF_DEFAULT_DIR_BUF_SIZE;
+    if (   (unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, cbDirBuf)
+        && info->cbDirBuf > 0) {
+        if (info->cbDirBuf <= _16M)
+            pSuperInfo->cbDirBuf = RT_ALIGN_32(info->cbDirBuf, PAGE_SIZE);
+        else
+            printk(KERN_WARNING "vboxsf: max directory buffer size (%#x) is out of range, using default (%#x) instead.\n",
+                   info->cMaxIoPages, pSuperInfo->cMaxIoPages);
+    }
+
+    /*
+     * TTLs.
+     */
+    pSuperInfo->msTTL = info->ttl;
+    if (info->ttl > 0)
+        pSuperInfo->cJiffiesDirCacheTTL = msecs_to_jiffies(info->ttl);
+    else if (info->ttl == 0 || info->ttl != -1)
+        pSuperInfo->cJiffiesDirCacheTTL = pSuperInfo->msTTL = 0;
+    else
+        pSuperInfo->cJiffiesDirCacheTTL = msecs_to_jiffies(VBSF_DEFAULT_TTL_MS);
+    pSuperInfo->cJiffiesInodeTTL = pSuperInfo->cJiffiesDirCacheTTL;
+
+    pSuperInfo->msDirCacheTTL = -1;
+    if (   (unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, msDirCacheTTL)
+        && info->msDirCacheTTL >= 0) {
+        if (info->msDirCacheTTL > 0) {
+            pSuperInfo->msDirCacheTTL       = info->msDirCacheTTL;
+            pSuperInfo->cJiffiesDirCacheTTL = msecs_to_jiffies(info->msDirCacheTTL);
+        } else {
+            pSuperInfo->msDirCacheTTL       = 0;
+            pSuperInfo->cJiffiesDirCacheTTL = 0;
+        }
+    }
+
+    pSuperInfo->msInodeTTL = -1;
+    if (   (unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, msInodeTTL)
+        && info->msInodeTTL >= 0) {
+        if (info->msInodeTTL > 0) {
+            pSuperInfo->msInodeTTL       = info->msInodeTTL;
+            pSuperInfo->cJiffiesInodeTTL = msecs_to_jiffies(info->msInodeTTL);
+        } else {
+            pSuperInfo->msInodeTTL       = 0;
+            pSuperInfo->cJiffiesInodeTTL = 0;
+        }
+    }
+
+    /*
+     * Caching.
+     */
+    pSuperInfo->enmCacheMode = kVbsfCacheMode_Strict;
+    if ((unsigned)info->length >= RT_UOFFSETOF(struct vbsf_mount_info_new, enmCacheMode)) {
+        switch (info->enmCacheMode) {
+            case kVbsfCacheMode_Default:
+            case kVbsfCacheMode_Strict:
+                break;
+            case kVbsfCacheMode_None:
+            case kVbsfCacheMode_Read:
+            case kVbsfCacheMode_ReadWrite:
+                pSuperInfo->enmCacheMode = info->enmCacheMode;
+                break;
+            default:
+                printk(KERN_WARNING "vboxsf: cache mode (%#x) is out of range, using default instead.\n", info->enmCacheMode);
+                break;
+        }
+    }
+}
+
+/**
+ * Allocate the super info structure and try map the host share.
+ */
+static int vbsf_super_info_alloc_and_map_it(struct vbsf_mount_info_new *info, struct vbsf_super_info **sf_gp)
+{
+    int rc;
+    SHFLSTRING *str_name;
+    size_t name_len, str_len;
+    struct vbsf_super_info *pSuperInfo;
+
+    TRACE();
+    *sf_gp = NULL; /* (old gcc maybe used initialized) */
+
+    name_len = RTStrNLen(info->name, sizeof(info->name));
+    if (name_len >= sizeof(info->name)) {
+        SFLOGRELBOTH(("vboxsf: Specified shared folder name is not zero terminated!\n"));
+        return -EINVAL;
+    }
+    if (RTStrNLen(info->nls_name, sizeof(info->nls_name)) >= sizeof(info->nls_name)) {
+        SFLOGRELBOTH(("vboxsf: Specified nls name is not zero terminated!\n"));
+        return -EINVAL;
+    }
+
+    /*
+     * Allocate memory.
+     */
+    str_len    = offsetof(SHFLSTRING, String.utf8) + name_len + 1;
+    str_name   = (PSHFLSTRING)kmalloc(str_len, GFP_KERNEL);
+    pSuperInfo = (struct vbsf_super_info *)kmalloc(sizeof(*pSuperInfo), GFP_KERNEL);
+    if (pSuperInfo && str_name) {
+        RT_ZERO(*pSuperInfo);
+
+        str_name->u16Length = name_len;
+        str_name->u16Size = name_len + 1;
+        memcpy(str_name->String.utf8, info->name, name_len + 1);
+
+        /*
+         * Init the NLS support, if needed.
+         */
+        rc = 0;
+#define _IS_UTF8(_str)  (strcmp(_str, "utf8") == 0)
+#define _IS_EMPTY(_str) (strcmp(_str, "") == 0)
+
+        /* Check if NLS charset is valid and not points to UTF8 table */
+        pSuperInfo->fNlsIsUtf8 = true;
+        if (info->nls_name[0]) {
+            if (_IS_UTF8(info->nls_name)) {
+                SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8\n"));
+                pSuperInfo->nls = NULL;
+            } else {
+                pSuperInfo->fNlsIsUtf8 = false;
+                pSuperInfo->nls = load_nls(info->nls_name);
+                if (pSuperInfo->nls) {
+                    SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=%s -> %p\n", info->nls_name, pSuperInfo->nls));
+                } else {
+                    SFLOGRELBOTH(("vboxsf: Failed to load nls '%s'!\n", info->nls_name));
+                    rc = -EINVAL;
+                }
+            }
+        } else {
+#ifdef CONFIG_NLS_DEFAULT
+            /* If no NLS charset specified, try to load the default
+             * one if it's not points to UTF8. */
+            if (!_IS_UTF8(CONFIG_NLS_DEFAULT)
+                && !_IS_EMPTY(CONFIG_NLS_DEFAULT)) {
+                pSuperInfo->fNlsIsUtf8 = false;
+                pSuperInfo->nls = load_nls_default();
+                SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: CONFIG_NLS_DEFAULT=%s -> %p\n", CONFIG_NLS_DEFAULT, pSuperInfo->nls));
+            } else {
+                SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8 (default %s)\n", CONFIG_NLS_DEFAULT));
+                pSuperInfo->nls = NULL;
+            }
+#else
+            SFLOGFLOW(("vbsf_super_info_alloc_and_map_it: nls=utf8 (no default)\n"));
+            pSuperInfo->nls = NULL;
+#endif
+        }
+#undef _IS_UTF8
+#undef _IS_EMPTY
+        if (rc == 0) {
+            /*
+             * Try mount it.
+             */
+            rc = VbglR0SfHostReqMapFolderWithContigSimple(str_name, virt_to_phys(str_name), RTPATH_DELIMITER,
+                                                          true /*fCaseSensitive*/, &pSuperInfo->map.root);
+            if (RT_SUCCESS(rc)) {
+                kfree(str_name);
+
+                /* The rest is shared with remount. */
+                vbsf_super_info_copy_remount_options(pSuperInfo, info);
+
+                *sf_gp = pSuperInfo;
+                return 0;
+            }
+
+            /*
+             * bail out:
+             */
+            if (rc == VERR_FILE_NOT_FOUND) {
+                LogRel(("vboxsf: SHFL_FN_MAP_FOLDER failed for '%s': share not found\n", info->name));
+                rc = -ENXIO;
+            } else {
+                LogRel(("vboxsf: SHFL_FN_MAP_FOLDER failed for '%s': %Rrc\n", info->name, rc));
+                rc = -EPROTO;
+            }
+            if (pSuperInfo->nls)
+                unload_nls(pSuperInfo->nls);
+        }
+    } else {
+        SFLOGRELBOTH(("vboxsf: Could not allocate memory for super info!\n"));
+        rc = -ENOMEM;
+    }
+    if (str_name)
+        kfree(str_name);
+    if (pSuperInfo)
+        kfree(pSuperInfo);
+    return rc;
+}
+
+/* unmap the share and free super info [pSuperInfo] */
+static void vbsf_super_info_free(struct vbsf_super_info *pSuperInfo)
+{
+    int rc;
+
+    TRACE();
+    rc = VbglR0SfHostReqUnmapFolderSimple(pSuperInfo->map.root);
+    if (RT_FAILURE(rc))
+        LogFunc(("VbglR0SfHostReqUnmapFolderSimple failed rc=%Rrc\n", rc));
+
+    if (pSuperInfo->nls)
+        unload_nls(pSuperInfo->nls);
+
+    kfree(pSuperInfo);
+}
+
+
+/**
+ * Initialize backing device related matters.
+ */
+static int vbsf_init_backing_dev(struct super_block *sb, struct vbsf_super_info *pSuperInfo)
+{
+    int rc = 0;
+#if RTLNX_VER_MIN(2,6,0)
+    /* Each new shared folder map gets a new uint64_t identifier,
+     * allocated in sequence.  We ASSUME the sequence will not wrap. */
+# if RTLNX_VER_MIN(2,6,26)
+    static uint64_t s_u64Sequence = 0;
+    uint64_t idSeqMine = ASMAtomicIncU64(&s_u64Sequence);
+# endif
+    struct backing_dev_info *bdi;
+
+# if RTLNX_VER_RANGE(4,0,0,  4,2,0)
+    pSuperInfo->bdi_org = sb->s_bdi;
+# endif
+
+# if RTLNX_VER_MIN(4,12,0)
+    rc = super_setup_bdi_name(sb, "vboxsf-%llu", (unsigned long long)idSeqMine);
+    if (!rc)
+        bdi = sb->s_bdi;
+    else
+        return rc;
+# else
+    bdi = &pSuperInfo->bdi;
+# endif
+
+    bdi->ra_pages = 0;                      /* No readahead */
+
+# if RTLNX_VER_MIN(2,6,12)
+    bdi->capabilities = 0
+#  ifdef BDI_CAP_MAP_DIRECT
+                      | BDI_CAP_MAP_DIRECT  /* MAP_SHARED */
+#  endif
+#  ifdef BDI_CAP_MAP_COPY
+                      | BDI_CAP_MAP_COPY    /* MAP_PRIVATE */
+#  endif
+#  ifdef BDI_CAP_READ_MAP
+                      | BDI_CAP_READ_MAP    /* can be mapped for reading */
+#  endif
+#  ifdef BDI_CAP_WRITE_MAP
+                      | BDI_CAP_WRITE_MAP   /* can be mapped for writing */
+#  endif
+#  ifdef BDI_CAP_EXEC_MAP
+                      | BDI_CAP_EXEC_MAP    /* can be mapped for execution */
+#  endif
+#  ifdef BDI_CAP_STRICTLIMIT
+#   if RTLNX_VER_MIN(4,19,0) /* Trouble with 3.16.x/debian8.  Process stops after dirty page throttling.
+                                                       * Only tested successfully with 4.19.  Maybe skip altogether? */
+                      | BDI_CAP_STRICTLIMIT;
+#   endif
+#  endif
+              ;
+#  ifdef BDI_CAP_STRICTLIMIT
+    /* Smalles possible amount of dirty pages: %1 of RAM.  We set this to
+       try reduce amount of data that's out of sync with the host side.
+       Besides, writepages isn't implemented, so flushing is extremely slow.
+       Note! Extremely slow linux 3.0.0 msync doesn't seem to be related to this setting. */
+    bdi_set_max_ratio(bdi, 1);
+#  endif
+# endif /* >= 2.6.12 */
+
+# if RTLNX_VER_RANGE(2,6,24,  4,12,0)
+    rc = bdi_init(&pSuperInfo->bdi);
+#  if RTLNX_VER_MIN(2,6,26)
+    if (!rc)
+        rc = bdi_register(&pSuperInfo->bdi, NULL, "vboxsf-%llu", (unsigned long long)idSeqMine);
+#  endif /* >= 2.6.26 */
+# endif  /* 4.11.0 > version >= 2.6.24 */
+
+# if RTLNX_VER_RANGE(2,6,34,  4,12,0)
+    if (!rc)
+        sb->s_bdi = bdi;
+# endif
+
+#endif   /* >= 2.6.0 */
+    return rc;
+}
+
+
+/**
+ * Undoes what vbsf_init_backing_dev did.
+ */
+static void vbsf_done_backing_dev(struct super_block *sb, struct vbsf_super_info *pSuperInfo)
+{
+#if RTLNX_VER_RANGE(2,6,24, 4,12,0)
+    bdi_destroy(&pSuperInfo->bdi);    /* includes bdi_unregister() */
+
+    /* Paranoia: Make sb->s_bdi not point at pSuperInfo->bdi, in case someone
+                 trouches it after this point (we may screw up something).  */
+# if RTLNX_VER_RANGE(4,0,0,  4,2,0)
+    sb->s_bdi = pSuperInfo->bdi_org; /* (noop_backing_dev_info is not exported) */
+# elif RTLNX_VER_RANGE(2,6,34,  4,10,0)
+    sb->s_bdi = &noop_backing_dev_info;
+# endif
+#endif
+}
+
+
+/**
+ * Creates the root inode and attaches it to the super block.
+ *
+ * @returns 0 on success, negative errno on failure.
+ * @param   sb          The super block.
+ * @param   pSuperInfo  Our super block info.
+ */
+static int vbsf_create_root_inode(struct super_block *sb, struct vbsf_super_info *pSuperInfo)
+{
+    SHFLFSOBJINFO fsinfo;
+    int rc;
+
+    /*
+     * Allocate and initialize the memory for our inode info structure.
+     */
+    struct vbsf_inode_info *sf_i = kmalloc(sizeof(*sf_i), GFP_KERNEL);
+    SHFLSTRING             *path = kmalloc(sizeof(SHFLSTRING) + 1, GFP_KERNEL);
+    if (sf_i && path) {
+        sf_i->handle = SHFL_HANDLE_NIL;
+        sf_i->force_restat = false;
+        RTListInit(&sf_i->HandleList);
+#ifdef VBOX_STRICT
+        sf_i->u32Magic = SF_INODE_INFO_MAGIC;
+#endif
+        sf_i->path = path;
+
+        path->u16Length = 1;
+        path->u16Size = 2;
+        path->String.utf8[0] = '/';
+        path->String.utf8[1] = 0;
+
+        /*
+         * Stat the root directory (for inode info).
+         */
+        rc = vbsf_stat(__func__, pSuperInfo, sf_i->path, &fsinfo, 0);
+        if (rc == 0) {
+            /*
+             * Create the actual inode structure.
+             * Note! ls -la does display '.' and '..' entries with st_ino == 0, so root is #1.
+             */
+#if RTLNX_VER_MIN(2,4,25)
+            struct inode *iroot = iget_locked(sb, 1);
+#else
+            struct inode *iroot = iget(sb, 1);
+#endif
+            if (iroot) {
+                vbsf_init_inode(iroot, sf_i, &fsinfo, pSuperInfo);
+                VBSF_SET_INODE_INFO(iroot, sf_i);
+
+#if RTLNX_VER_MIN(2,4,25)
+                unlock_new_inode(iroot);
+#endif
+
+                /*
+                 * Now make it a root inode.
+                 */
+#if RTLNX_VER_MIN(3,4,0)
+                sb->s_root = d_make_root(iroot);
+#else
+                sb->s_root = d_alloc_root(iroot);
+#endif
+                if (sb->s_root) {
+
+                    return 0;
+                }
+
+                SFLOGRELBOTH(("vboxsf: d_make_root failed!\n"));
+#if RTLNX_VER_MAX(3,4,0) /* d_make_root calls iput */
+                iput(iroot);
+#endif
+                /* iput() will call vbsf_evict_inode()/vbsf_clear_inode(). */
+                sf_i = NULL;
+                path = NULL;
+
+                rc = -ENOMEM;
+            } else {
+                SFLOGRELBOTH(("vboxsf: failed to allocate root inode!\n"));
+                rc = -ENOMEM;
+            }
+        } else
+            SFLOGRELBOTH(("vboxsf: could not stat root of share: %d\n", rc));
+    } else {
+        SFLOGRELBOTH(("vboxsf: Could not allocate memory for root inode info!\n"));
+        rc = -ENOMEM;
+    }
+    if (sf_i)
+        kfree(sf_i);
+    if (path)
+        kfree(path);
+    return rc;
+}
+
+
+#if RTLNX_VER_MAX(5,1,0)
+static void vbsf_init_mount_info(struct vbsf_mount_info_new *mount_info,
+    const char *sf_name)
+{
+    mount_info->ttl = mount_info->msDirCacheTTL = mount_info->msInodeTTL = -1;
+    mount_info->dmode = mount_info->fmode = ~0U;
+    mount_info->enmCacheMode = kVbsfCacheMode_Strict;
+    mount_info->length = sizeof(struct vbsf_mount_info_new);
+    if (sf_name) {
+# if RTLNX_VER_MAX(2,5,69)
+        strncpy(mount_info->name, sf_name, sizeof(mount_info->name));
+        mount_info->name[sizeof(mount_info->name)-1] = 0;
+# else
+        strlcpy(mount_info->name, sf_name, sizeof(mount_info->name));
+# endif
+    }
+}
+#endif
+
+#if RTLNX_VER_RANGE(2,6,0,  5,1,0)
+/**
+ * The following section of code uses the Linux match_token() family of
+ * routines to parse string-based mount options.
+ */
+enum {
+    Opt_iocharset,  /* nls_name[] */
+    Opt_nls,        /* alias for iocharset */
+    Opt_uid,
+    Opt_gid,
+    Opt_ttl,
+    Opt_dmode,
+    Opt_fmode,
+    Opt_dmask,
+    Opt_fmask,
+    Opt_umask,
+    Opt_maxiopages,
+    Opt_dirbuf,
+    Opt_dcachettl,
+    Opt_inodettl,
+    Opt_cachemode,  /* enum vbsf_cache_mode */
+    Opt_tag,
+    Opt_err
+};
+
+# if RTLNX_VER_MAX(2,6,28)
+static match_table_t vbsf_tokens = {
+# else
+static const match_table_t vbsf_tokens = {
+# endif
+    { Opt_iocharset,  "iocharset=%s" },
+    { Opt_nls,        "nls=%s" },
+    { Opt_uid,        "uid=%u" },
+    { Opt_gid,        "gid=%u" },
+    { Opt_ttl,        "ttl=%u" },
+    { Opt_dmode,      "dmode=%o" },
+    { Opt_fmode,      "fmode=%o" },
+    { Opt_dmask,      "dmask=%o" },
+    { Opt_fmask,      "fmask=%o" },
+    { Opt_umask,      "umask=%o" },
+    { Opt_maxiopages, "maxiopages=%u" },
+    { Opt_dirbuf,     "dirbuf=%u" },
+    { Opt_dcachettl,  "dcachettl=%u" },
+    { Opt_inodettl,   "inodettl=%u" },
+    { Opt_cachemode,  "cache=%s" },
+    { Opt_tag,        "tag=%s" },  /* private option for automounter */
+    { Opt_err,        NULL }
+};
+
+static int vbsf_parse_mount_options(char *options,
+    struct vbsf_mount_info_new *mount_info)
+{
+    substring_t args[MAX_OPT_ARGS];
+    int option;
+    int token;
+    char *p;
+    char *iocharset;
+    char *cachemode;
+    char *tag;
+
+    if (!options)
+        return -EINVAL;
+
+    while ((p = strsep(&options, ",")) != NULL) {
+        if (!*p)
+            continue;
+
+        token = match_token(p, vbsf_tokens, args);
+        switch (token) {
+        case Opt_iocharset:
+        case Opt_nls:
+            iocharset = match_strdup(&args[0]);
+            if (!iocharset) {
+                SFLOGRELBOTH(("vboxsf: Could not allocate memory for iocharset!\n"));
+                return -ENOMEM;
+            }
+            strlcpy(mount_info->nls_name, iocharset,
+                sizeof(mount_info->nls_name));
+            kfree(iocharset);
+            break;
+        case Opt_uid:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->uid = option;
+            break;
+        case Opt_gid:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->gid = option;
+            break;
+        case Opt_ttl:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->ttl = option;
+            break;
+        case Opt_dmode:
+            if (match_octal(&args[0], &option))
+                return -EINVAL;
+            mount_info->dmode = option;
+            break;
+        case Opt_fmode:
+            if (match_octal(&args[0], &option))
+                return -EINVAL;
+            mount_info->fmode = option;
+            break;
+        case Opt_dmask:
+            if (match_octal(&args[0], &option))
+                return -EINVAL;
+            mount_info->dmask = option;
+            break;
+        case Opt_fmask:
+            if (match_octal(&args[0], &option))
+                return -EINVAL;
+            mount_info->fmask = option;
+            break;
+        case Opt_umask:
+            if (match_octal(&args[0], &option))
+                return -EINVAL;
+            mount_info->dmask = mount_info->fmask = option;
+            break;
+        case Opt_maxiopages:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->cMaxIoPages = option;
+            break;
+        case Opt_dirbuf:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->cbDirBuf = option;
+            break;
+        case Opt_dcachettl:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->msDirCacheTTL = option;
+            break;
+        case Opt_inodettl:
+            if (match_int(&args[0], &option))
+                return -EINVAL;
+            mount_info->msInodeTTL = option;
+            break;
+        case Opt_cachemode: {
+            cachemode = match_strdup(&args[0]);
+            if (!cachemode) {
+                SFLOGRELBOTH(("vboxsf: Could not allocate memory for cachemode!\n"));
+                return -ENOMEM;
+            }
+            if (!strcmp(cachemode, "default") || !strcmp(cachemode, "strict"))
+                mount_info->enmCacheMode = kVbsfCacheMode_Strict;
+            else if (!strcmp(cachemode, "none"))
+                mount_info->enmCacheMode = kVbsfCacheMode_None;
+            else if (!strcmp(cachemode, "read"))
+                mount_info->enmCacheMode = kVbsfCacheMode_Read;
+            else if (!strcmp(cachemode, "readwrite"))
+                mount_info->enmCacheMode = kVbsfCacheMode_ReadWrite;
+            else
+                printk(KERN_WARNING "vboxsf: cache mode (%s) is out of range, using default instead.\n", cachemode);
+            kfree(cachemode);
+            break;
+        }
+        case Opt_tag:
+            tag = match_strdup(&args[0]);
+            if (!tag) {
+                SFLOGRELBOTH(("vboxsf: Could not allocate memory for automount tag!\n"));
+                return -ENOMEM;
+            }
+            strlcpy(mount_info->szTag, tag, sizeof(mount_info->szTag));
+            kfree(tag);
+            break;
+        default:
+            printk(KERN_ERR "unrecognised mount option \"%s\"", p);
+            return -EINVAL;
+        }
+    }
+
+    return 0;
+}
+#endif /* 5.1.0 > version >= 2.6.0 */
+
+
+#if RTLNX_VER_MAX(2,6,0)
+/**
+ * Linux kernel versions older than 2.6.0 don't have the match_token() routines
+ * so we parse the string-based mount options manually here.
+ */
+static int vbsf_parse_mount_options(char *options,
+    struct vbsf_mount_info_new *mount_info)
+{
+    char *value;
+    char *option;
+
+    if (!options)
+        return -EINVAL;
+
+# if RTLNX_VER_MIN(2,3,9)
+    while ((option = strsep(&options, ",")) != NULL) {
+# else
+    for (option = strtok(options, ","); option; option = strtok(NULL, ",")) {
+# endif
+        if (!*option)
+            continue;
+
+        value = strchr(option, '=');
+        if (value)
+            *value++ = '\0';
+
+        if (!strcmp(option, "iocharset") || !strcmp(option, "nls")) {
+            if (!value || !*value)
+                return -EINVAL;
+            strncpy(mount_info->nls_name, value, sizeof(mount_info->nls_name));
+            mount_info->nls_name[sizeof(mount_info->nls_name)-1] = 0;
+        } else if (!strcmp(option, "uid")) {
+            mount_info->uid = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "gid")) {
+            mount_info->gid = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "ttl")) {
+            mount_info->ttl = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "dmode")) {
+            mount_info->dmode = simple_strtoul(value, &value, 8);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "fmode")) {
+            mount_info->fmode = simple_strtoul(value, &value, 8);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "dmask")) {
+            mount_info->dmask = simple_strtoul(value, &value, 8);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "fmask")) {
+            mount_info->fmask = simple_strtoul(value, &value, 8);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "umask")) {
+            mount_info->dmask = mount_info->fmask = simple_strtoul(value,
+                &value, 8);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "maxiopages")) {
+            mount_info->cMaxIoPages = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "dirbuf")) {
+            mount_info->cbDirBuf = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "dcachettl")) {
+            mount_info->msDirCacheTTL = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "inodettl")) {
+            mount_info->msInodeTTL = simple_strtoul(value, &value, 0);
+            if (*value)
+                return -EINVAL;
+        } else if (!strcmp(option, "cache")) {
+            if (!value || !*value)
+                return -EINVAL;
+            if (!strcmp(value, "default") || !strcmp(value, "strict"))
+                mount_info->enmCacheMode = kVbsfCacheMode_Strict;
+            else if (!strcmp(value, "none"))
+                mount_info->enmCacheMode = kVbsfCacheMode_None;
+            else if (!strcmp(value, "read"))
+                mount_info->enmCacheMode = kVbsfCacheMode_Read;
+            else if (!strcmp(value, "readwrite"))
+                mount_info->enmCacheMode = kVbsfCacheMode_ReadWrite;
+            else
+                printk(KERN_WARNING "vboxsf: cache mode (%s) is out of range, using default instead.\n", value);
+        } else if (!strcmp(option, "tag")) {
+            if (!value || !*value)
+                return -EINVAL;
+            strncpy(mount_info->szTag, value, sizeof(mount_info->szTag));
+            mount_info->szTag[sizeof(mount_info->szTag)-1] = 0;
+        } else if (!strcmp(option, "sf_name")) {
+            if (!value || !*value)
+                return -EINVAL;
+            strncpy(mount_info->name, value, sizeof(mount_info->name));
+            mount_info->name[sizeof(mount_info->name)-1] = 0;
+        } else {
+            printk(KERN_ERR "unrecognised mount option \"%s\"", option);
+            return -EINVAL;
+        }
+    }
+
+    return 0;
+}
+#endif
+
+
+/**
+ * This is called by vbsf_read_super_24(), vbsf_read_super_26(), and
+ * vbsf_get_tree() when vfs mounts the fs and wants to read the super_block.
+ *
+ * Calls vbsf_super_info_alloc_and_map_it() to map the folder and allocate super
+ * information structure.
+ *
+ * Initializes @a sb, initializes root inode and dentry.
+ *
+ * Should respect @a flags.
+ */
+#if RTLNX_VER_MIN(5,1,0)
+static int vbsf_read_super_aux(struct super_block *sb, struct fs_context *fc)
+#else
+static int vbsf_read_super_aux(struct super_block *sb, void *data, int flags)
+#endif
+{
+    int rc;
+    struct vbsf_super_info *pSuperInfo;
+
+    TRACE();
+#if RTLNX_VER_MAX(5,1,0)
+    if (!data) {
+        SFLOGRELBOTH(("vboxsf: No mount data. Is mount.vboxsf installed (typically in /sbin)?\n"));
+        return -EINVAL;
+    }
+
+    if (flags & MS_REMOUNT) {
+        SFLOGRELBOTH(("vboxsf: Remounting is not supported!\n"));
+        return -ENOSYS;
+    }
+#endif
+
+    /*
+     * Create our super info structure and map the shared folder.
+     */
+#if RTLNX_VER_MIN(5,1,0)
+    struct vbsf_mount_info_new *info = fc->fs_private;
+    rc = vbsf_super_info_alloc_and_map_it(info, &pSuperInfo);
+#else
+    rc = vbsf_super_info_alloc_and_map_it((struct vbsf_mount_info_new *)data, &pSuperInfo);
+#endif
+    if (rc == 0) {
+        /*
+         * Initialize the super block structure (must be done before
+         * root inode creation).
+         */
+        sb->s_magic     = 0xface;
+        sb->s_blocksize = 1024;
+#if RTLNX_VER_MIN(2,4,3)
+        /* Required for seek/sendfile (see 'loff_t max' in fs/read_write.c / do_sendfile()). */
+# if defined MAX_LFS_FILESIZE
+        sb->s_maxbytes  = MAX_LFS_FILESIZE;
+# elif BITS_PER_LONG == 32
+        sb->s_maxbytes  = (loff_t)ULONG_MAX << PAGE_SHIFT;
+# else
+        sb->s_maxbytes  = INT64_MAX;
+# endif
+#endif
+#if RTLNX_VER_MIN(2,6,11)
+        sb->s_time_gran = 1; /* This might be a little optimistic for windows hosts, where it should be 100. */
+#endif
+        sb->s_op        = &g_vbsf_super_ops;
+#if RTLNX_VER_MIN(2,6,38)
+        sb->s_d_op      = &vbsf_dentry_ops;
+#endif
+
+        /*
+         * Initialize the backing device.  This is important for memory mapped
+         * files among other things.
+         */
+        rc = vbsf_init_backing_dev(sb, pSuperInfo);
+        if (rc == 0) {
+            /*
+             * Create the root inode and we're done.
+             */
+            rc = vbsf_create_root_inode(sb, pSuperInfo);
+            if (rc == 0) {
+                VBSF_SET_SUPER_INFO(sb, pSuperInfo);
+                SFLOGFLOW(("vbsf_read_super_aux: returns successfully\n"));
+                return 0;
+            }
+            vbsf_done_backing_dev(sb, pSuperInfo);
+        } else
+            SFLOGRELBOTH(("vboxsf: backing device information initialization failed: %d\n", rc));
+        vbsf_super_info_free(pSuperInfo);
+    }
+    return rc;
+}
+
+
+/**
+ * This is called when vfs is about to destroy the @a inode.
+ *
+ * We must free the inode info structure here.
+ */
+#if RTLNX_VER_MIN(2,6,36)
+static void vbsf_evict_inode(struct inode *inode)
+#else
+static void vbsf_clear_inode(struct inode *inode)
+#endif
+{
+    struct vbsf_inode_info *sf_i;
+
+    TRACE();
+
+    /*
+     * Flush stuff.
+     */
+#if RTLNX_VER_MIN(2,6,36)
+    truncate_inode_pages(&inode->i_data, 0);
+# if RTLNX_VER_MIN(3,5,0)
+    clear_inode(inode);
+# else
+    end_writeback(inode);
+# endif
+#endif
+    /*
+     * Clean up our inode info.
+     */
+    sf_i = VBSF_GET_INODE_INFO(inode);
+    if (sf_i) {
+        VBSF_SET_INODE_INFO(inode, NULL);
+
+        Assert(sf_i->u32Magic == SF_INODE_INFO_MAGIC);
+        BUG_ON(!sf_i->path);
+        kfree(sf_i->path);
+        vbsf_handle_drop_chain(sf_i);
+# ifdef VBOX_STRICT
+        sf_i->u32Magic = SF_INODE_INFO_MAGIC_DEAD;
+# endif
+        kfree(sf_i);
+    }
+}
+
+
+/* this is called by vfs when it wants to populate [inode] with data.
+   the only thing that is known about inode at this point is its index
+   hence we can't do anything here, and let lookup/whatever with the
+   job to properly fill then [inode] */
+#if RTLNX_VER_MAX(2,6,25)
+static void vbsf_read_inode(struct inode *inode)
+{
+}
+#endif
+
+
+/* vfs is done with [sb] (umount called) call [vbsf_super_info_free] to unmap
+   the folder and free [pSuperInfo] */
+static void vbsf_put_super(struct super_block *sb)
+{
+    struct vbsf_super_info *pSuperInfo;
+
+    pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+    BUG_ON(!pSuperInfo);
+    vbsf_done_backing_dev(sb, pSuperInfo);
+    vbsf_super_info_free(pSuperInfo);
+}
+
+
+/**
+ * Get file system statistics.
+ */
+#if RTLNX_VER_MIN(2,6,18)
+static int vbsf_statfs(struct dentry *dentry, struct kstatfs *stat)
+#elif RTLNX_VER_MIN(2,5,73)
+static int vbsf_statfs(struct super_block *sb, struct kstatfs *stat)
+#else
+static int vbsf_statfs(struct super_block *sb, struct statfs *stat)
+#endif
+{
+#if RTLNX_VER_MIN(2,6,18)
+    struct super_block *sb = dentry->d_inode->i_sb;
+#endif
+    int rc;
+    VBOXSFVOLINFOREQ *pReq = (VBOXSFVOLINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
+    if (pReq) {
+        SHFLVOLINFO            *pVolInfo   = &pReq->VolInfo;
+        struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+        rc = VbglR0SfHostReqQueryVolInfo(pSuperInfo->map.root, pReq, SHFL_HANDLE_ROOT);
+        if (RT_SUCCESS(rc)) {
+            stat->f_type   = UINT32_C(0x786f4256); /* 'VBox' little endian */
+            stat->f_bsize  = pVolInfo->ulBytesPerAllocationUnit;
+#if RTLNX_VER_MIN(2,5,73)
+            stat->f_frsize = pVolInfo->ulBytesPerAllocationUnit;
+#endif
+            stat->f_blocks = pVolInfo->ullTotalAllocationBytes
+                           / pVolInfo->ulBytesPerAllocationUnit;
+            stat->f_bfree  = pVolInfo->ullAvailableAllocationBytes
+                           / pVolInfo->ulBytesPerAllocationUnit;
+            stat->f_bavail = pVolInfo->ullAvailableAllocationBytes
+                           / pVolInfo->ulBytesPerAllocationUnit;
+            stat->f_files  = 1000;
+            stat->f_ffree  = 1000000; /* don't return 0 here since the guest may think
+                                       * that it is not possible to create any more files */
+            stat->f_fsid.val[0] = 0;
+            stat->f_fsid.val[1] = 0;
+            stat->f_namelen = 255;
+#if RTLNX_VER_MIN(2,6,36)
+            stat->f_flags = 0; /* not valid */
+#endif
+            RT_ZERO(stat->f_spare);
+            rc = 0;
+        } else
+            rc = -RTErrConvertToErrno(rc);
+        VbglR0PhysHeapFree(pReq);
+    } else
+        rc = -ENOMEM;
+    return rc;
+}
+
+#if RTLNX_VER_MIN(5,1,0)
+static int vbsf_remount_fs(struct super_block *sb,
+                           struct vbsf_mount_info_new *info)
+#else
+static int vbsf_remount_fs(struct super_block *sb, int *flags, char *data)
+#endif
+{
+#if RTLNX_VER_MIN(2,4,23)
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+    struct vbsf_inode_info *sf_i;
+    struct inode *iroot;
+    SHFLFSOBJINFO fsinfo;
+    int err;
+    Assert(pSuperInfo);
+
+# if RTLNX_VER_MIN(5,1,0)
+    vbsf_super_info_copy_remount_options(pSuperInfo, info);
+# else
+    if (VBSF_IS_MOUNT_VBOXSF_DATA(data)) {
+        vbsf_super_info_copy_remount_options(pSuperInfo, (struct vbsf_mount_info_new *)data);
+    } else {
+        struct vbsf_mount_info_new mount_opts = { '\0' };
+        vbsf_init_mount_info(&mount_opts, NULL);
+        err = vbsf_parse_mount_options(data, &mount_opts);
+        if (err)
+            return err;
+        vbsf_super_info_copy_remount_options(pSuperInfo, &mount_opts);
+    }
+# endif
+
+    /* '.' and '..' entries are st_ino == 0 so root is #1 */
+    iroot = ilookup(sb, 1);
+    if (!iroot)
+        return -ENOSYS;
+
+    sf_i = VBSF_GET_INODE_INFO(iroot);
+    err = vbsf_stat(__func__, pSuperInfo, sf_i->path, &fsinfo, 0);
+    BUG_ON(err != 0);
+    vbsf_init_inode(iroot, sf_i, &fsinfo, pSuperInfo);
+    iput(iroot);
+    return 0;
+#else  /* < 2.4.23 */
+    return -ENOSYS;
+#endif /* < 2.4.23 */
+}
+
+
+/**
+ * Show mount options.
+ *
+ * This is needed by the VBoxService automounter in order for it to pick up
+ * the the 'szTag' option value it sets on its mount.
+ */
+#if RTLNX_VER_MAX(3,3,0)
+static int vbsf_show_options(struct seq_file *m, struct vfsmount *mnt)
+#else
+static int vbsf_show_options(struct seq_file *m, struct dentry *root)
+#endif
+{
+#if RTLNX_VER_MAX(3,3,0)
+    struct super_block     *sb         = mnt->mnt_sb;
+#else
+    struct super_block     *sb         = root->d_sb;
+#endif
+    struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(sb);
+    if (pSuperInfo) {
+        /* Performance related options: */
+        if (pSuperInfo->msTTL != -1)
+            seq_printf(m, ",ttl=%d", pSuperInfo->msTTL);
+        if (pSuperInfo->msDirCacheTTL >= 0)
+            seq_printf(m, ",dcachettl=%d", pSuperInfo->msDirCacheTTL);
+        if (pSuperInfo->msInodeTTL >= 0)
+            seq_printf(m, ",inodettl=%d", pSuperInfo->msInodeTTL);
+        if (pSuperInfo->cMaxIoPages != VBSF_DEFAULT_MAX_IO_PAGES)
+            seq_printf(m, ",maxiopages=%u", pSuperInfo->cMaxIoPages);
+        if (pSuperInfo->cbDirBuf != VBSF_DEFAULT_DIR_BUF_SIZE)
+            seq_printf(m, ",dirbuf=%u", pSuperInfo->cbDirBuf);
+        switch (pSuperInfo->enmCacheMode) {
+            default: AssertFailed();
+            case kVbsfCacheMode_Strict:
+                break;
+            case kVbsfCacheMode_None:       seq_puts(m, ",cache=none"); break;
+            case kVbsfCacheMode_Read:       seq_puts(m, ",cache=read"); break;
+            case kVbsfCacheMode_ReadWrite:  seq_puts(m, ",cache=readwrite"); break;
+        }
+
+        /* Attributes and NLS: */
+        seq_printf(m, ",iocharset=%s", pSuperInfo->nls ? pSuperInfo->nls->charset : "utf8");
+        seq_printf(m, ",uid=%u,gid=%u", pSuperInfo->uid, pSuperInfo->gid);
+        if (pSuperInfo->dmode != ~0)
+            seq_printf(m, ",dmode=0%o", pSuperInfo->dmode);
+        if (pSuperInfo->fmode != ~0)
+            seq_printf(m, ",fmode=0%o", pSuperInfo->fmode);
+        if (pSuperInfo->dmask != 0)
+            seq_printf(m, ",dmask=0%o", pSuperInfo->dmask);
+        if (pSuperInfo->fmask != 0)
+            seq_printf(m, ",fmask=0%o", pSuperInfo->fmask);
+
+        /* Misc: */
+        if (pSuperInfo->szTag[0] != '\0') {
+            seq_puts(m, ",tag=");
+            seq_escape(m, pSuperInfo->szTag, " \t\n\\");
+        }
+    }
+    return 0;
+}
+
+
+/**
+ * Super block operations.
+ */
+static struct super_operations g_vbsf_super_ops = {
+#if RTLNX_VER_MAX(2,6,36)
+    .clear_inode  = vbsf_clear_inode,
+#else
+    .evict_inode  = vbsf_evict_inode,
+#endif
+#if RTLNX_VER_MAX(2,6,25)
+    .read_inode   = vbsf_read_inode,
+#endif
+    .put_super    = vbsf_put_super,
+    .statfs       = vbsf_statfs,
+#if RTLNX_VER_MAX(5,1,0)
+    .remount_fs   = vbsf_remount_fs,
+#endif
+    .show_options = vbsf_show_options
+};
+
+
+
+/*********************************************************************************************************************************
+*   File system type related stuff.                                                                                              *
+*********************************************************************************************************************************/
+
+#if RTLNX_VER_RANGE(2,5,4,  5,1,0)
+
+static int vbsf_read_super_26(struct super_block *sb, void *data, int flags)
+{
+    int err;
+
+    TRACE();
+    err = vbsf_read_super_aux(sb, data, flags);
+    if (err)
+        printk(KERN_DEBUG "vbsf_read_super_aux err=%d\n", err);
+
+    return err;
+}
+
+# if RTLNX_VER_MIN(2,6,39)
+static struct dentry *sf_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
+{
+    TRACE();
+
+    if (!VBSF_IS_MOUNT_VBOXSF_DATA(data)) {
+        int rc;
+        struct vbsf_mount_info_new mount_opts = { '\0' };
+
+        vbsf_init_mount_info(&mount_opts, dev_name);
+        rc = vbsf_parse_mount_options(data, &mount_opts);
+        if (rc)
+            return ERR_PTR(rc);
+        return mount_nodev(fs_type, flags, &mount_opts, vbsf_read_super_26);
+    } else {
+        return mount_nodev(fs_type, flags, data, vbsf_read_super_26);
+    }
+}
+# elif RTLNX_VER_MIN(2,6,18)
+static int vbsf_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+{
+    TRACE();
+
+    if (!VBSF_IS_MOUNT_VBOXSF_DATA(data)) {
+        int rc;
+        struct vbsf_mount_info_new mount_opts = { '\0' };
+
+        vbsf_init_mount_info(&mount_opts, dev_name);
+        rc = vbsf_parse_mount_options(data, &mount_opts);
+        if (rc)
+            return rc;
+        return get_sb_nodev(fs_type, flags, &mount_opts, vbsf_read_super_26,
+            mnt);
+    } else {
+        return get_sb_nodev(fs_type, flags, data, vbsf_read_super_26, mnt);
+    }
+}
+# else /* 2.6.18 > version >= 2.5.4 */
+static struct super_block *vbsf_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
+{
+    TRACE();
+
+    if (!VBSF_IS_MOUNT_VBOXSF_DATA(data)) {
+        int rc;
+        struct vbsf_mount_info_new mount_opts = { '\0' };
+
+        vbsf_init_mount_info(&mount_opts, dev_name);
+        rc = vbsf_parse_mount_options(data, &mount_opts);
+        if (rc)
+            return ERR_PTR(rc);
+        return get_sb_nodev(fs_type, flags, &mount_opts, vbsf_read_super_26);
+    } else {
+        return get_sb_nodev(fs_type, flags, data, vbsf_read_super_26);
+    }
+}
+# endif
+#endif /* 5.1.0 > version >= 2.5.4 */
+
+#if RTLNX_VER_MAX(2,5,4)  /* < 2.5.4 */
+
+static struct super_block *vbsf_read_super_24(struct super_block *sb, void *data, int flags)
+{
+    int err;
+
+    TRACE();
+
+    if (!VBSF_IS_MOUNT_VBOXSF_DATA(data)) {
+        int rc;
+        struct vbsf_mount_info_new mount_opts = { '\0' };
+
+        vbsf_init_mount_info(&mount_opts, NULL);
+        rc = vbsf_parse_mount_options(data, &mount_opts);
+        if (rc)
+            return ERR_PTR(rc);
+        err = vbsf_read_super_aux(sb, &mount_opts, flags);
+    } else {
+        err = vbsf_read_super_aux(sb, data, flags);
+    }
+    if (err) {
+        printk(KERN_DEBUG "vbsf_read_super_aux err=%d\n", err);
+        return NULL;
+    }
+
+    return sb;
+}
+
+static DECLARE_FSTYPE(g_vboxsf_fs_type, "vboxsf", vbsf_read_super_24, 0);
+
+#endif /* < 2.5.4 */
+
+#if RTLNX_VER_MIN(5,1,0)
+
+/**
+ * The following section of code uses the Linux filesystem mount API (also
+ * known as the "filesystem context API") to parse string-based mount options.
+ * The API is described here:
+ * https://www.kernel.org/doc/Documentation/filesystems/mount_api.txt
+ */
+enum vbsf_cache_modes {
+    VBSF_CACHE_DEFAULT,
+    VBSF_CACHE_NONE,
+    VBSF_CACHE_STRICT,
+    VBSF_CACHE_READ,
+    VBSF_CACHE_RW
+};
+
+static const struct constant_table vbsf_param_cache_mode[] = {
+        { "default",      VBSF_CACHE_DEFAULT },
+        { "none",         VBSF_CACHE_NONE },
+        { "strict",       VBSF_CACHE_STRICT },
+        { "read",         VBSF_CACHE_READ },
+        { "readwrite",    VBSF_CACHE_RW },
+        {}
+};
+
+enum {
+    Opt_iocharset,  /* nls_name[] */
+    Opt_nls,        /* alias for iocharset */
+    Opt_uid,
+    Opt_gid,
+    Opt_ttl,
+    Opt_dmode,
+    Opt_fmode,
+    Opt_dmask,
+    Opt_fmask,
+    Opt_umask,
+    Opt_maxiopages,
+    Opt_dirbuf,
+    Opt_dcachettl,
+    Opt_inodettl,
+    Opt_cachemode,  /* enum vbsf_cache_mode */
+    Opt_tag
+};
+
+# if RTLNX_VER_MAX(5,6,0)
+static const struct fs_parameter_spec vbsf_fs_specs[] = {
+# else
+static const struct fs_parameter_spec vbsf_fs_parameters[] = {
+# endif
+    fsparam_string("iocharset",   Opt_iocharset),
+    fsparam_string("nls",         Opt_nls),
+    fsparam_u32   ("uid",         Opt_uid),
+    fsparam_u32   ("gid",         Opt_gid),
+    fsparam_u32   ("ttl",         Opt_ttl),
+    fsparam_u32oct("dmode",       Opt_dmode),
+    fsparam_u32oct("fmode",       Opt_fmode),
+    fsparam_u32oct("dmask",       Opt_dmask),
+    fsparam_u32oct("fmask",       Opt_fmask),
+    fsparam_u32oct("umask",       Opt_umask),
+    fsparam_u32   ("maxiopages",  Opt_maxiopages),
+    fsparam_u32   ("dirbuf",      Opt_dirbuf),
+    fsparam_u32   ("dcachettl",   Opt_dcachettl),
+    fsparam_u32   ("inodettl",    Opt_inodettl),
+# if RTLNX_VER_MAX(5,6,0)
+    fsparam_enum  ("cache",       Opt_cachemode),
+# else
+    fsparam_enum  ("cache",       Opt_cachemode, vbsf_param_cache_mode),
+# endif
+    fsparam_string("tag",         Opt_tag),
+    {}
+};
+
+# if RTLNX_VER_MAX(5,6,0)
+static const struct fs_parameter_enum vbsf_fs_enums[] = {
+    { Opt_cachemode,    "default",      VBSF_CACHE_DEFAULT },
+    { Opt_cachemode,    "none",         VBSF_CACHE_NONE },
+    { Opt_cachemode,    "strict",       VBSF_CACHE_STRICT },
+    { Opt_cachemode,    "read",         VBSF_CACHE_READ },
+    { Opt_cachemode,    "readwrite",    VBSF_CACHE_RW },
+    {}
+};
+
+static const struct fs_parameter_description vbsf_fs_parameters = {
+    .name       = "vboxsf",
+    .specs      = vbsf_fs_specs,
+    .enums      = vbsf_fs_enums
+};
+# endif
+
+/**
+ * Parse the (string-based) mount options passed in as -o foo,bar=123,etc.
+ */
+static int vbsf_parse_param(struct fs_context *fc, struct fs_parameter *param)
+{
+    struct fs_parse_result result;
+    struct vbsf_mount_info_new *info = fc->fs_private;
+    int opt;
+
+# if RTLNX_VER_MAX(5,6,0)
+    opt = fs_parse(fc, &vbsf_fs_parameters, param, &result);
+# else
+    opt = fs_parse(fc, vbsf_fs_parameters, param, &result);
+# endif
+    if (opt < 0)
+        return opt;
+
+    switch (opt) {
+    case Opt_iocharset:
+    case Opt_nls:
+        strlcpy(info->nls_name, param->string, sizeof(info->nls_name));
+        break;
+    case Opt_uid:
+        info->uid = result.uint_32;
+        break;
+    case Opt_gid:
+        info->gid = result.uint_32;
+        break;
+    case Opt_ttl:
+        info->ttl = result.uint_32;
+        break;
+    case Opt_dmode:
+        if (result.uint_32 & ~0777)
+            return invalf(fc, "Invalid dmode specified: '%o'", result.uint_32);
+        info->dmode = result.uint_32;
+        break;
+    case Opt_fmode:
+        if (result.uint_32 & ~0777)
+            return invalf(fc, "Invalid fmode specified: '%o'", result.uint_32);
+        info->fmode = result.uint_32;
+        break;
+    case Opt_dmask:
+        if (result.uint_32 & ~07777)
+            return invalf(fc, "Invalid dmask specified: '%o'", result.uint_32);
+        info->dmask = result.uint_32;
+        break;
+    case Opt_fmask:
+        if (result.uint_32 & ~07777)
+            return invalf(fc, "Invalid fmask specified: '%o'", result.uint_32);
+        info->fmask = result.uint_32;
+        break;
+    case Opt_umask:
+        if (result.uint_32 & ~07777)
+            return invalf(fc, "Invalid umask specified: '%o'", result.uint_32);
+        info->dmask = info->fmask = result.uint_32;
+        break;
+    case Opt_maxiopages:
+        info->cMaxIoPages = result.uint_32;
+        break;
+    case Opt_dirbuf:
+        info->cbDirBuf = result.uint_32;
+        break;
+    case Opt_dcachettl:
+        info->msDirCacheTTL = result.uint_32;
+        break;
+    case Opt_inodettl:
+        info->msInodeTTL = result.uint_32;
+        break;
+    case Opt_cachemode:
+        if (result.uint_32 == VBSF_CACHE_DEFAULT || result.uint_32 == VBSF_CACHE_STRICT)
+            info->enmCacheMode = kVbsfCacheMode_Strict;
+        else if (result.uint_32 == VBSF_CACHE_NONE)
+            info->enmCacheMode = kVbsfCacheMode_None;
+        else if (result.uint_32 == VBSF_CACHE_READ)
+            info->enmCacheMode = kVbsfCacheMode_Read;
+        else if (result.uint_32 == VBSF_CACHE_RW)
+            info->enmCacheMode = kVbsfCacheMode_ReadWrite;
+        else
+            printk(KERN_WARNING "vboxsf: cache mode (%u) is out of range, using default instead.\n", result.uint_32);
+        break;
+    case Opt_tag:
+        strlcpy(info->szTag, param->string, sizeof(info->szTag));
+        break;
+    default:
+        return invalf(fc, "Invalid mount option: '%s'", param->key);
+    }
+
+    return 0;
+}
+
+/**
+ * Parse the mount options provided whether by the mount.vboxsf utility
+ * which supplies the mount information as a page of data or else as a
+ * string in the following format: key[=val][,key[=val]]*.
+ */
+static int vbsf_parse_monolithic(struct fs_context *fc, void *data)
+{
+    struct vbsf_mount_info_new *info = fc->fs_private;
+
+    if (data) {
+        if (VBSF_IS_MOUNT_VBOXSF_DATA(data)) {
+            memcpy(info, data, sizeof(struct vbsf_mount_info_new));
+        } else {
+            /* this will call vbsf_parse_param() */
+            return generic_parse_monolithic(fc, data);
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * Clean up the filesystem-specific part of the filesystem context.
+ */
+static void vbsf_free_ctx(struct fs_context *fc)
+{
+    struct vbsf_mount_info_new *info = fc->fs_private;
+
+    if (info) {
+        kfree(info);
+        fc->fs_private = NULL;
+    }
+}
+
+/**
+ * Create the mountable root and superblock which can then be used later for
+ * mounting the shared folder.  The superblock is populated by
+ * vbsf_read_super_aux() which also sets up the shared folder mapping and the
+ * related paperwork in preparation for mounting the shared folder.
+ */
+static int vbsf_get_tree(struct fs_context *fc)
+{
+    struct vbsf_mount_info_new *info = fc->fs_private;
+
+    if (!fc->source) {
+        SFLOGRELBOTH(("vboxsf: No shared folder specified\n"));
+        return invalf(fc, "vboxsf: No shared folder specified");
+    }
+
+    /* fc->source (the shared folder name) is set after vbsf_init_fs_ctx() */
+    strlcpy(info->name, fc->source, sizeof(info->name));
+
+# if RTLNX_VER_MAX(5,3,0)
+    return vfs_get_super(fc, vfs_get_independent_super, vbsf_read_super_aux);
+# else
+    return get_tree_nodev(fc, vbsf_read_super_aux);
+# endif
+}
+
+/**
+ * Reconfigures the superblock based on the mount information stored in the
+ * filesystem context.  Called via '-o remount' (aka mount(2) with MS_REMOUNT)
+ * and is the equivalent of .fs_remount.
+ */
+static int vbsf_reconfigure(struct fs_context *fc)
+{
+    struct vbsf_mount_info_new *info = fc->fs_private;
+    struct super_block *sb = fc->root->d_sb;
+
+    return vbsf_remount_fs(sb, info);
+}
+
+static const struct fs_context_operations vbsf_context_ops = {
+    .parse_param         = vbsf_parse_param,
+    .parse_monolithic    = vbsf_parse_monolithic,
+    .free                = vbsf_free_ctx,
+    .get_tree            = vbsf_get_tree,
+    .reconfigure         = vbsf_reconfigure
+};
+
+/**
+ * Set up the filesystem mount context.
+ */
+static int vbsf_init_fs_context(struct fs_context *fc)
+{
+    struct vbsf_mount_info_new *info = fc->fs_private;
+
+    info = kzalloc(sizeof(*info), GFP_KERNEL);
+    if (!info) {
+        SFLOGRELBOTH(("vboxsf: Could not allocate memory for mount options\n"));
+        return -ENOMEM;
+    }
+
+    /* set default values for the mount information structure */
+    info->ttl = info->msDirCacheTTL = info->msInodeTTL = -1;
+    info->dmode = info->fmode = ~0U;
+    info->enmCacheMode = kVbsfCacheMode_Strict;
+    info->length = sizeof(struct vbsf_mount_info_new);
+
+    fc->fs_private = info;
+    fc->ops = &vbsf_context_ops;
+
+    return 0;
+}
+#endif /* >= 5.1.0 */
+
+
+#if RTLNX_VER_MIN(2,5,4)
+/**
+ * File system registration structure.
+ */
+static struct file_system_type g_vboxsf_fs_type = {
+    .owner = THIS_MODULE,
+    .name = "vboxsf",
+# if RTLNX_VER_MIN(5,1,0)
+    .init_fs_context = vbsf_init_fs_context,
+#  if RTLNX_VER_MAX(5,6,0)
+    .parameters = &vbsf_fs_parameters,
+#  else
+    .parameters = vbsf_fs_parameters,
+#  endif
+# elif RTLNX_VER_MIN(2,6,39)
+    .mount = sf_mount,
+# else
+    .get_sb = vbsf_get_sb,
+# endif
+    .kill_sb = kill_anon_super
+};
+#endif /* >= 2.5.4 */
+
+
+/*********************************************************************************************************************************
+*   Module stuff                                                                                                                 *
+*********************************************************************************************************************************/
+
+/**
+ * Called on module initialization.
+ */
+static int __init init(void)
+{
+    int rc;
+    SFLOGFLOW(("vboxsf: init\n"));
+
+    /*
+     * Must be paranoid about the vbsf_mount_info_new size.
+     */
+    AssertCompile(sizeof(struct vbsf_mount_info_new) <= PAGE_SIZE);
+    if (sizeof(struct vbsf_mount_info_new) > PAGE_SIZE) {
+        printk(KERN_ERR
+               "vboxsf: Mount information structure is too large %lu\n"
+               "vboxsf: Must be less than or equal to %lu\n",
+               (unsigned long)sizeof(struct vbsf_mount_info_new),
+               (unsigned long)PAGE_SIZE);
+        return -EINVAL;
+    }
+
+    /*
+     * Initialize stuff.
+     */
+    spin_lock_init(&g_SfHandleLock);
+    rc = VbglR0SfInit();
+    if (RT_SUCCESS(rc)) {
+        /*
+         * Try connect to the shared folder HGCM service.
+         * It is possible it is not there.
+         */
+        rc = VbglR0SfConnect(&g_SfClient);
+        if (RT_SUCCESS(rc)) {
+            /*
+             * Query host HGCM features and afterwards (must be last) shared folder features.
+             */
+            rc = VbglR0QueryHostFeatures(&g_fHostFeatures);
+            if (RT_FAILURE(rc))
+            {
+                LogRel(("vboxsf: VbglR0QueryHostFeatures failed: rc=%Rrc (ignored)\n", rc));
+                g_fHostFeatures = 0;
+            }
+            VbglR0SfHostReqQueryFeaturesSimple(&g_fSfFeatures, &g_uSfLastFunction);
+            LogRel(("vboxsf: g_fHostFeatures=%#x g_fSfFeatures=%#RX64 g_uSfLastFunction=%u\n",
+                    g_fHostFeatures, g_fSfFeatures, g_uSfLastFunction));
+
+            /*
+             * Tell the shared folder service about our expectations:
+             *      - UTF-8 strings (rather than UTF-16)
+             *      - Wheter to return or follow (default) symbolic links.
+             */
+            rc = VbglR0SfHostReqSetUtf8Simple();
+            if (RT_SUCCESS(rc)) {
+                if (!g_fFollowSymlinks) {
+                    rc = VbglR0SfHostReqSetSymlinksSimple();
+                    if (RT_FAILURE(rc))
+                        printk(KERN_WARNING "vboxsf: Host unable to enable showing symlinks, rc=%d\n", rc);
+                }
+                /*
+                 * Now that we're ready for action, try register the
+                 * file system with the kernel.
+                 */
+                rc = register_filesystem(&g_vboxsf_fs_type);
+                if (rc == 0) {
+                    printk(KERN_INFO "vboxsf: Successfully loaded version " VBOX_VERSION_STRING " r" __stringify(VBOX_SVN_REV) "\n");
+#ifdef VERMAGIC_STRING
+                    LogRel(("vboxsf: Successfully loaded version " VBOX_VERSION_STRING " r" __stringify(VBOX_SVN_REV) " on %s (LINUX_VERSION_CODE=%#x)\n",
+                            VERMAGIC_STRING, LINUX_VERSION_CODE));
+#elif defined(UTS_RELEASE)
+                    LogRel(("vboxsf: Successfully loaded version " VBOX_VERSION_STRING " r" __stringify(VBOX_SVN_REV) " on %s (LINUX_VERSION_CODE=%#x)\n",
+                            UTS_RELEASE, LINUX_VERSION_CODE));
+#else
+                    LogRel(("vboxsf: Successfully loaded version " VBOX_VERSION_STRING " r" __stringify(VBOX_SVN_REV) " (LINUX_VERSION_CODE=%#x)\n", LINUX_VERSION_CODE));
+#endif
+                    return 0;
+                }
+
+                /*
+                 * Failed. Bail out.
+                 */
+                LogRel(("vboxsf: register_filesystem failed: rc=%d\n", rc));
+            } else  {
+                LogRel(("vboxsf: VbglR0SfSetUtf8 failed, rc=%Rrc\n", rc));
+                rc = -EPROTO;
+            }
+            VbglR0SfDisconnect(&g_SfClient);
+        } else {
+            LogRel(("vboxsf: VbglR0SfConnect failed, rc=%Rrc\n", rc));
+            rc = rc == VERR_HGCM_SERVICE_NOT_FOUND ? -EHOSTDOWN : -ECONNREFUSED;
+        }
+        VbglR0SfTerm();
+    } else {
+        LogRel(("vboxsf: VbglR0SfInit failed, rc=%Rrc\n", rc));
+        rc = -EPROTO;
+    }
+    return rc;
+}
+
+
+/**
+ * Called on module finalization.
+ */
+static void __exit fini(void)
+{
+    SFLOGFLOW(("vboxsf: fini\n"));
+
+    unregister_filesystem(&g_vboxsf_fs_type);
+    VbglR0SfDisconnect(&g_SfClient);
+    VbglR0SfTerm();
+}
+
+
+/*
+ * Module parameters.
+ */
+#if RTLNX_VER_MIN(2,5,52)
+module_param_named(follow_symlinks, g_fFollowSymlinks, int, 0);
+MODULE_PARM_DESC(follow_symlinks,
+                 "Let host resolve symlinks rather than showing them");
+#endif
+
+
+/*
+ * Module declaration related bits.
+ */
+module_init(init);
+module_exit(fini);
+
+MODULE_DESCRIPTION(VBOX_PRODUCT " VFS Module for Host File System Access");
+MODULE_AUTHOR(VBOX_VENDOR);
+MODULE_LICENSE("GPL and additional rights");
+#ifdef MODULE_ALIAS_FS
+MODULE_ALIAS_FS("vboxsf");
+#endif
+#ifdef MODULE_VERSION
+MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV));
+#endif
+