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

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

48 files changed, 14120 insertions, 0 deletions

diff --git a/src/VBox/Additions/solaris/.scm-settings b/src/VBox/Additions/solaris/.scm-settings
new file mode 100644
index 00000000..5c7d3f1e
--- /dev/null
+++ b/src/VBox/Additions/solaris/.scm-settings
@@ -0,0 +1,44 @@
+# $Id: .scm-settings $
+## @file
+# Source code massager settings for the Solaris guest additions.
+#
+
+#
+# Copyright (C) 2010-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+# The whole lot is dual licensed.
+--license-ose-dual
+
+--filter-out-dirs  "/DRM/include/."
+
+--filter-out-files /Installer/vboxguest.depend
+--filter-out-files /Installer/vboxguest.pkginfo
+--filter-out-files /Installer/vboxguest.space
+/Installer/postinstall.sh: --no-convert-tabs --license-ose-dual
+/Installer/vbox_vendor_select: --treat-as .sh --license-based-on-mit --no-convert-tabs
+
+/Mouse/vboxms.conf: --treat-as .sh
+
+--filter-out-dirs  "/SharedFolders/solaris10/sys/."
+/SharedFolders/*: --no-convert-tabs
+
+/DRM/vboxvideo_drm.c: --no-convert-tabs
+
diff --git a/src/VBox/Additions/solaris/DRM/Makefile.kmk b/src/VBox/Additions/solaris/DRM/Makefile.kmk
new file mode 100644
index 00000000..0cdb388d
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/Makefile.kmk
@@ -0,0 +1,61 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the vboxvideo DRM module (Solaris kernel OpenGL module).
+#
+
+#
+# Copyright (C) 2009-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+
+SUB_DEPTH = ../../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#ifneq ($(KBUILD_HOST),solaris)
+#$(error "The Solaris guest additions can only be built on Solaris!")
+#endif
+
+#
+# vboxvideo - The Video DRM (Direct Rendering Module) kernel module
+#
+SYSMODS.solaris        += vboxvideo
+vboxvideo_TEMPLATE      = VBOXGUESTR0
+vboxvideo_DEFS          = VBOX_WITH_HGCM VBOX_SVN_REV=$(VBOX_SVN_REV)
+vboxvideo_DEPS         += $(VBOX_SVN_REV_KMK)
+if ($(VBOX_SOLARIS_11_UPDATE_VERSION) > 3)
+vboxvideo_DEFS         += VBOX_WITH_SYSTEM_QUEUE_H
+endif
+vboxvideo_INCS         := \
+	include/
+vboxvideo_SOURCES       = \
+	vboxvideo_drm.c
+vboxvideo_LIBS          = \
+	$(VBOX_LIB_VBGL_R0) \
+	$(VBOX_LIB_IPRT_GUEST_R0)
+ifeq ($(KBUILD_HOST),solaris)
+ vboxvideo_LDFLAGS         += -N misc/drm
+else
+ vboxvideo_SOURCES         += deps.asm
+ vboxvideo_deps.asm_ASFLAGS = -f bin -g null
+endif
+
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/Additions/solaris/DRM/deps.asm b/src/VBox/Additions/solaris/DRM/deps.asm
new file mode 100644
index 00000000..7452a925
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/deps.asm
@@ -0,0 +1,37 @@
+; $Id: deps.asm $
+;; @file
+; Solaris kernel module dependency
+;
+
+;
+; Copyright (C) 2012-2020 Oracle Corporation
+;
+; This file is part of VirtualBox Open Source Edition (OSE), as
+; available from http://www.virtualbox.org. This file is free software;
+; you can redistribute it and/or modify it under the terms of the GNU
+; General Public License (GPL) as published by the Free Software
+; Foundation, in version 2 as it comes in the "COPYING" file of the
+; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+; VirtualBox OSE distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+
+%include "iprt/solaris/kmoddeps.mac"
+
+kmoddeps_header  ; ELF header, section table and shared string table
+
+kmoddeps_dynstr_start  ; ELF .dynstr section
+kmoddeps_dynstr_string str_misc_ctf, "misc/ctf"
+kmoddeps_dynstr_end
+
+kmoddeps_dynamic_start  ; ELF .dynamic section
+kmoddeps_dynamic_needed str_misc_ctf
+kmoddeps_dynamic_end
diff --git a/src/VBox/Additions/solaris/DRM/include/drm.h b/src/VBox/Additions/solaris/DRM/include/drm.h
new file mode 100644
index 00000000..5bff1e1e
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/include/drm.h
@@ -0,0 +1,820 @@
+/* BEGIN CSTYLED */
+
+/**
+ * \file drm.h
+ * Header for the Direct Rendering Manager
+ *
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ * \par Acknowledgments:
+ * Dec 1999, Richard Henderson <rth@twiddle.net>, move to generic \c cmpxchg.
+ */
+
+/*
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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.
+ */
+
+/**
+ * \mainpage
+ *
+ * The Direct Rendering Manager (DRM) is a device-independent kernel-level
+ * device driver that provides support for the XFree86 Direct Rendering
+ * Infrastructure (DRI).
+ *
+ * The DRM supports the Direct Rendering Infrastructure (DRI) in four major
+ * ways:
+ *     -# The DRM provides synchronized access to the graphics hardware via
+ *        the use of an optimized two-tiered lock.
+ *     -# The DRM enforces the DRI security policy for access to the graphics
+ *        hardware by only allowing authenticated X11 clients access to
+ *        restricted regions of memory.
+ *     -# The DRM provides a generic DMA engine, complete with multiple
+ *        queues and the ability to detect the need for an OpenGL context
+ *        switch.
+ *     -# The DRM is extensible via the use of small device-specific modules
+ *        that rely extensively on the API exported by the DRM module.
+ *
+ */
+
+/*
+ * Copyright 2009-2010 Oracle Corporation
+ * All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _DRM_H_
+#define _DRM_H_
+
+#include <sys/types32.h>
+
+#ifndef __user
+#define __user
+#endif
+
+#ifdef __GNUC__
+# define DEPRECATED  __attribute__ ((deprecated))
+#else
+# define DEPRECATED
+# define __volatile__ volatile
+#endif
+
+#if defined(__linux__)
+#include <asm/ioctl.h>		/* For _IO* macros */
+#define DRM_IOCTL_NR(n)		_IOC_NR(n)
+#define DRM_IOC_VOID		_IOC_NONE
+#define DRM_IOC_READ		_IOC_READ
+#define DRM_IOC_WRITE		_IOC_WRITE
+#define DRM_IOC_READWRITE	_IOC_READ|_IOC_WRITE
+#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+#if (defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) && defined(IN_MODULE)
+/* Prevent name collision when including sys/ioccom.h */
+#undef ioctl
+#include <sys/ioccom.h>
+#define ioctl(a,b,c)		xf86ioctl(a,b,c)
+#else
+#include <sys/ioccom.h>
+#endif				/* __FreeBSD__ && xf86ioctl */
+#define DRM_IOCTL_NR(n)		((n) & 0xff)
+#define DRM_IOC_VOID		IOC_VOID
+#define DRM_IOC_READ		IOC_OUT
+#define DRM_IOC_WRITE		IOC_IN
+#define DRM_IOC_READWRITE	IOC_INOUT
+#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+#endif
+
+/* Solaris-specific. */
+#if defined(__SOLARIS__) || defined(sun)
+#define	_IOC_NR(nr)	(((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
+
+#define	_IOC_NRBITS	8
+#define	_IOC_TYPEBITS   8
+#define	_IOC_SIZEBITS   14
+#define	_IOC_DIRBITS    2
+
+#define	_IOC_NRMASK	((1 << _IOC_NRBITS)-1)
+#define	_IOC_TYPEMASK   ((1 << _IOC_TYPEBITS)-1)
+#define	_IOC_SIZEMASK   ((1 << _IOC_SIZEBITS)-1)
+#define	_IOC_DIRMASK    ((1 << _IOC_DIRBITS)-1)
+
+#define	_IOC_NRSHIFT    0
+#define	_IOC_TYPESHIFT  (_IOC_NRSHIFT+_IOC_NRBITS)
+#define	_IOC_SIZESHIFT  (_IOC_TYPESHIFT+_IOC_TYPEBITS)
+#define	_IOC_DIRSHIFT   (_IOC_SIZESHIFT+_IOC_SIZEBITS)
+
+#define	_IOC_NONE	0U
+#define	_IOC_WRITE	1U
+#define	_IOC_READ	2U
+
+#define	_IOC(dir, type, nr, size) \
+	(((dir)  << _IOC_DIRSHIFT) | \
+	((type) << _IOC_TYPESHIFT) | \
+	((nr)   << _IOC_NRSHIFT) | \
+	((size) << _IOC_SIZESHIFT))
+
+/* used for X server compile */
+#if !defined(_KERNEL)
+#define	_IO(type, nr)		_IOC(_IOC_NONE, (type), (nr), 0)
+#define	_IOR(type, nr, size)	_IOC(_IOC_READ, (type), (nr), sizeof (size))
+#define	_IOW(type, nr, size)	_IOC(_IOC_WRITE, (type), (nr), sizeof (size))
+#define	_IOWR(type, nr, size)	_IOC(_IOC_READ|_IOC_WRITE, \
+				(type), (nr), sizeof (size))
+
+#define	_IOC_DIR(nr)		(((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
+#define	_IOC_TYPE(nr)		(((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
+#define	_IOC_NR(nr)		(((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
+#define	_IOC_SIZE(nr)		(((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
+
+#define	IOC_IN			(_IOC_WRITE << _IOC_DIRSHIFT)
+#define	IOC_OUT			(_IOC_READ << _IOC_DIRSHIFT)
+#define	IOC_INOUT		((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
+#define	IOCSIZE_MASK		(_IOC_SIZEMASK << _IOC_SIZESHIFT)
+#define	IOCSIZE_SHIFT		(_IOC_SIZESHIFT)
+#endif /* _KERNEL */
+
+#define	DRM_IOCTL_NR(n)		_IOC_NR(n)
+#define	DRM_IOC_VOID		IOC_VOID
+#define	DRM_IOC_READ		IOC_OUT
+#define	DRM_IOC_WRITE		IOC_IN
+#define	DRM_IOC_READWRITE	IOC_INOUT
+#define	DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
+
+#endif /* __Solaris__ or sun */
+#define XFREE86_VERSION(major,minor,patch,snap) \
+		((major << 16) | (minor << 8) | patch)
+
+#ifndef CONFIG_XFREE86_VERSION
+#define CONFIG_XFREE86_VERSION XFREE86_VERSION(4,1,0,0)
+#endif
+
+#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
+#define DRM_PROC_DEVICES "/proc/devices"
+#define DRM_PROC_MISC	 "/proc/misc"
+#define DRM_PROC_DRM	 "/proc/drm"
+#define DRM_DEV_DRM	 "/dev/drm"
+#define DRM_DEV_MODE	 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
+#define DRM_DEV_UID	 0
+#define DRM_DEV_GID	 0
+#endif
+
+#if CONFIG_XFREE86_VERSION >= XFREE86_VERSION(4,1,0,0)
+#ifdef __OpenBSD__
+#define DRM_MAJOR       81
+#endif
+#if defined(__linux__) || defined(__NetBSD__)
+#define DRM_MAJOR       226
+#endif
+#define DRM_MAX_MINOR   15
+#endif
+#define DRM_NAME	"drm"	  /**< Name in kernel, /dev, and /proc */
+#define DRM_MIN_ORDER	5	  /**< At least 2^5 bytes = 32 bytes */
+#define DRM_MAX_ORDER	22	  /**< Up to 2^22 bytes = 4MB */
+#define DRM_RAM_PERCENT 10	  /**< How much system ram can we lock? */
+
+#define _DRM_LOCK_HELD	0x80000000U /**< Hardware lock is held */
+#define _DRM_LOCK_CONT	0x40000000U /**< Hardware lock is contended */
+#define _DRM_LOCK_IS_HELD(lock)	   ((lock) & _DRM_LOCK_HELD)
+#define _DRM_LOCK_IS_CONT(lock)	   ((lock) & _DRM_LOCK_CONT)
+#define _DRM_LOCKING_CONTEXT(lock) ((lock) & ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT))
+
+#if defined(__linux__)
+#if defined(__KERNEL__)
+typedef __u64 drm_u64_t;
+#else
+typedef unsigned long long drm_u64_t;
+#endif
+
+typedef unsigned int drm_handle_t;
+#else
+#include <sys/types.h>
+typedef uint64_t drm_u64_t;
+typedef unsigned long long drm_handle_t;	/**< To mapped regions */
+#endif
+typedef unsigned int drm_context_t;	/**< GLXContext handle */
+typedef unsigned int drm_drawable_t;
+typedef unsigned int drm_magic_t;	/**< Magic for authentication */
+
+/**
+ * Cliprect.
+ *
+ * \warning If you change this structure, make sure you change
+ * XF86DRIClipRectRec in the server as well
+ *
+ * \note KW: Actually it's illegal to change either for
+ * backwards-compatibility reasons.
+ */
+typedef struct drm_clip_rect {
+	unsigned short x1;
+	unsigned short y1;
+	unsigned short x2;
+	unsigned short y2;
+} drm_clip_rect_t;
+
+/**
+ * Drawable information.
+ */
+typedef struct drm_drawable_info {
+	unsigned int num_rects;
+	drm_clip_rect_t *rects;
+} drm_drawable_info_t;
+
+/**
+ * Texture region,
+ */
+typedef struct drm_tex_region {
+	unsigned char next;
+	unsigned char prev;
+	unsigned char in_use;
+	unsigned char padding;
+	unsigned int age;
+} drm_tex_region_t;
+
+/**
+ * Hardware lock.
+ *
+ * The lock structure is a simple cache-line aligned integer.  To avoid
+ * processor bus contention on a multiprocessor system, there should not be any
+ * other data stored in the same cache line.
+ */
+typedef struct drm_hw_lock {
+	__volatile__ unsigned int lock;		/**< lock variable */
+	char padding[60];			/**< Pad to cache line */
+} drm_hw_lock_t;
+
+/* This is beyond ugly, and only works on GCC.  However, it allows me to use
+ * drm.h in places (i.e., in the X-server) where I can't use size_t.  The real
+ * fix is to use uint32_t instead of size_t, but that fix will break existing
+ * LP64 (i.e., PowerPC64, SPARC64, IA-64, Alpha, etc.) systems.  That *will*
+ * eventually happen, though.  I chose 'unsigned long' to be the fallback type
+ * because that works on all the platforms I know about.  Hopefully, the
+ * real fix will happen before that bites us.
+ */
+
+#ifdef __SIZE_TYPE__
+# define DRM_SIZE_T __SIZE_TYPE__
+#else
+#if !defined(__SOLARIS__) && !defined(sun)
+# warning "__SIZE_TYPE__ not defined.  Assuming sizeof(size_t) == sizeof(unsigned long)!"
+#endif
+# define DRM_SIZE_T unsigned long
+#endif
+
+/**
+ * DRM_IOCTL_VERSION ioctl argument type.
+ *
+ * \sa drmGetVersion().
+ */
+typedef struct drm_version {
+	int version_major;	  /**< Major version */
+	int version_minor;	  /**< Minor version */
+	int version_patchlevel;	  /**< Patch level */
+	DRM_SIZE_T name_len;	  /**< Length of name buffer */
+	char __user *name;		  /**< Name of driver */
+	DRM_SIZE_T date_len;	  /**< Length of date buffer */
+	char __user *date;		  /**< User-space buffer to hold date */
+	DRM_SIZE_T desc_len;	  /**< Length of desc buffer */
+	char __user *desc;		  /**< User-space buffer to hold desc */
+} drm_version_t;
+
+/**
+ * DRM_IOCTL_GET_UNIQUE ioctl argument type.
+ *
+ * \sa drmGetBusid() and drmSetBusId().
+ */
+typedef struct drm_unique {
+	DRM_SIZE_T unique_len;	  /**< Length of unique */
+	char __user *unique;	  /**< Unique name for driver instantiation */
+} drm_unique_t;
+
+#undef DRM_SIZE_T
+
+typedef struct drm_list {
+	int count;		  /**< Length of user-space structures */
+	drm_version_t __user *version;
+} drm_list_t;
+
+typedef struct drm_block {
+	int unused;
+} drm_block_t;
+
+/**
+ * DRM_IOCTL_CONTROL ioctl argument type.
+ *
+ * \sa drmCtlInstHandler() and drmCtlUninstHandler().
+ */
+typedef struct drm_control {
+	enum {
+		DRM_ADD_COMMAND,
+		DRM_RM_COMMAND,
+		DRM_INST_HANDLER,
+		DRM_UNINST_HANDLER
+	} func;
+	int irq;
+} drm_control_t;
+
+/**
+ * Type of memory to map.
+ */
+typedef enum drm_map_type {
+	_DRM_FRAME_BUFFER = 0,	  /**< WC (no caching), no core dump */
+	_DRM_REGISTERS = 1,	  /**< no caching, no core dump */
+	_DRM_SHM = 2,		  /**< shared, cached */
+	_DRM_AGP = 3,		  /**< AGP/GART */
+	_DRM_SCATTER_GATHER = 4,  /**< Scatter/gather memory for PCI DMA */
+	_DRM_CONSISTENT = 5,	  /**< Consistent memory for PCI DMA */
+	_DRM_TTM	= 6
+} drm_map_type_t;
+
+/**
+ * Memory mapping flags.
+ */
+typedef enum drm_map_flags {
+	_DRM_RESTRICTED = 0x01,	     /**< Cannot be mapped to user-virtual */
+	_DRM_READ_ONLY = 0x02,
+	_DRM_LOCKED = 0x04,	     /**< shared, cached, locked */
+	_DRM_KERNEL = 0x08,	     /**< kernel requires access */
+	_DRM_WRITE_COMBINING = 0x10, /**< use write-combining if available */
+	_DRM_CONTAINS_LOCK = 0x20,   /**< SHM page that contains lock */
+	_DRM_REMOVABLE = 0x40,	     /**< Removable mapping */
+	_DRM_DRIVER = 0x80	     /**< Managed by driver */
+} drm_map_flags_t;
+
+typedef struct drm_ctx_priv_map {
+	unsigned int ctx_id;	 /**< Context requesting private mapping */
+	void *handle;		 /**< Handle of map */
+} drm_ctx_priv_map_t;
+
+/**
+ * DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls
+ * argument type.
+ *
+ * \sa drmAddMap().
+ */
+typedef struct drm_map {
+	unsigned long long offset;	 /**< Requested physical address (0 for SAREA)*/
+	unsigned long long handle;
+				/**< User-space: "Handle" to pass to mmap() */
+				/**< Kernel-space: kernel-virtual address */
+	unsigned long size;	 /**< Requested physical size (bytes) */
+	drm_map_type_t type;	 /**< Type of memory to map */
+	drm_map_flags_t flags;	 /**< Flags */
+	int mtrr;		 /**< MTRR slot used */
+	/*   Private data */
+} drm_map_t;
+
+/**
+ * DRM_IOCTL_GET_CLIENT ioctl argument type.
+ */
+typedef struct drm_client {
+	int idx;		/**< Which client desired? */
+	int auth;		/**< Is client authenticated? */
+	unsigned long pid;	/**< Process ID */
+	unsigned long uid;	/**< User ID */
+	unsigned long magic;	/**< Magic */
+	unsigned long iocs;	/**< Ioctl count */
+} drm_client_t;
+
+typedef enum {
+	_DRM_STAT_LOCK,
+	_DRM_STAT_OPENS,
+	_DRM_STAT_CLOSES,
+	_DRM_STAT_IOCTLS,
+	_DRM_STAT_LOCKS,
+	_DRM_STAT_UNLOCKS,
+	_DRM_STAT_VALUE,	/**< Generic value */
+	_DRM_STAT_BYTE,		/**< Generic byte counter (1024bytes/K) */
+	_DRM_STAT_COUNT,	/**< Generic non-byte counter (1000/k) */
+
+	_DRM_STAT_IRQ,		/**< IRQ */
+	_DRM_STAT_PRIMARY,	/**< Primary DMA bytes */
+	_DRM_STAT_SECONDARY,	/**< Secondary DMA bytes */
+	_DRM_STAT_DMA,		/**< DMA */
+	_DRM_STAT_SPECIAL,	/**< Special DMA (e.g., priority or polled) */
+	_DRM_STAT_MISSED	/**< Missed DMA opportunity */
+	    /* Add to the *END* of the list */
+} drm_stat_type_t;
+
+/**
+ * DRM_IOCTL_GET_STATS ioctl argument type.
+ */
+typedef struct drm_stats {
+	unsigned long count;
+	struct {
+		unsigned long value;
+		drm_stat_type_t type;
+	} data[15];
+} drm_stats_t;
+
+/**
+ * Hardware locking flags.
+ */
+typedef enum drm_lock_flags {
+	_DRM_LOCK_READY = 0x01,	     /**< Wait until hardware is ready for DMA */
+	_DRM_LOCK_QUIESCENT = 0x02,  /**< Wait until hardware quiescent */
+	_DRM_LOCK_FLUSH = 0x04,	     /**< Flush this context's DMA queue first */
+	_DRM_LOCK_FLUSH_ALL = 0x08,  /**< Flush all DMA queues first */
+	/* These *HALT* flags aren't supported yet
+	   -- they will be used to support the
+	   full-screen DGA-like mode. */
+	_DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */
+	_DRM_HALT_CUR_QUEUES = 0x20  /**< Halt all current queues */
+} drm_lock_flags_t;
+
+/**
+ * DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument type.
+ *
+ * \sa drmGetLock() and drmUnlock().
+ */
+typedef struct drm_lock {
+	int context;
+	drm_lock_flags_t flags;
+} drm_lock_t;
+
+/**
+ * DMA flags
+ *
+ * \warning
+ * These values \e must match xf86drm.h.
+ *
+ * \sa drm_dma.
+ */
+typedef enum drm_dma_flags {
+	/* Flags for DMA buffer dispatch */
+	_DRM_DMA_BLOCK = 0x01,	      /**<
+				       * Block until buffer dispatched.
+				       *
+				       * \note The buffer may not yet have
+				       * been processed by the hardware --
+				       * getting a hardware lock with the
+				       * hardware quiescent will ensure
+				       * that the buffer has been
+				       * processed.
+				       */
+	_DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */
+	_DRM_DMA_PRIORITY = 0x04,     /**< High priority dispatch */
+
+	/* Flags for DMA buffer request */
+	_DRM_DMA_WAIT = 0x10,	      /**< Wait for free buffers */
+	_DRM_DMA_SMALLER_OK = 0x20,   /**< Smaller-than-requested buffers OK */
+	_DRM_DMA_LARGER_OK = 0x40     /**< Larger-than-requested buffers OK */
+} drm_dma_flags_t;
+
+/**
+ * DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type.
+ *
+ * \sa drmAddBufs().
+ */
+typedef enum {
+	_DRM_PAGE_ALIGN = 0x01,	/**< Align on page boundaries for DMA */
+	_DRM_AGP_BUFFER = 0x02,	/**< Buffer is in AGP space */
+	_DRM_SG_BUFFER  = 0x04,	/**< Scatter/gather memory buffer */
+	_DRM_FB_BUFFER  = 0x08,  /**< Buffer is in frame buffer */
+	_DRM_PCI_BUFFER_RO = 0x10 /**< Map PCI DMA buffer read-only */
+} drm_buf_flag;
+typedef struct drm_buf_desc {
+	int count;		 /**< Number of buffers of this size */
+	int size;		 /**< Size in bytes */
+	int low_mark;		 /**< Low water mark */
+	int high_mark;		 /**< High water mark */
+	drm_buf_flag flags;
+	unsigned long agp_start; /**<
+				  * Start address of where the AGP buffers are
+				  * in the AGP aperture
+				  */
+} drm_buf_desc_t;
+
+/**
+ * DRM_IOCTL_INFO_BUFS ioctl argument type.
+ */
+typedef struct drm_buf_info {
+	int count;		  /**< Number of buffers described in list */
+	drm_buf_desc_t __user *list;	  /**< List of buffer descriptions */
+} drm_buf_info_t;
+
+/**
+ * DRM_IOCTL_FREE_BUFS ioctl argument type.
+ */
+typedef struct drm_buf_free {
+	int count;
+	int __user *list;
+} drm_buf_free_t;
+
+/**
+ * Buffer information
+ *
+ * \sa drm_buf_map.
+ */
+typedef struct drm_buf_pub {
+	int idx;		       /**< Index into the master buffer list */
+	int total;		       /**< Buffer size */
+	int used;		       /**< Amount of buffer in use (for DMA) */
+	void __user *address;	       /**< Address of buffer */
+} drm_buf_pub_t;
+
+/**
+ * DRM_IOCTL_MAP_BUFS ioctl argument type.
+ */
+typedef struct drm_buf_map {
+	int count;		/**< Length of the buffer list */
+#if defined(__cplusplus)
+	void __user *c_virtual;
+#else
+	void __user *virtual;		/**< Mmap'd area in user-virtual */
+#endif
+	drm_buf_pub_t __user *list;	/**< Buffer information */
+	int	fd;
+} drm_buf_map_t;
+
+/**
+ * DRM_IOCTL_DMA ioctl argument type.
+ *
+ * Indices here refer to the offset into the buffer list in drm_buf_get.
+ *
+ * \sa drmDMA().
+ */
+typedef struct drm_dma {
+	int context;			  /**< Context handle */
+	int send_count;			  /**< Number of buffers to send */
+	int __user *send_indices;	  /**< List of handles to buffers */
+	int __user *send_sizes;		  /**< Lengths of data to send */
+	drm_dma_flags_t flags;		  /**< Flags */
+	int request_count;		  /**< Number of buffers requested */
+	int request_size;		  /**< Desired size for buffers */
+	int __user *request_indices;	 /**< Buffer information */
+	int __user *request_sizes;
+	int granted_count;		  /**< Number of buffers granted */
+} drm_dma_t;
+
+typedef enum {
+	_DRM_CONTEXT_PRESERVED = 0x01,
+	_DRM_CONTEXT_2DONLY = 0x02
+} drm_ctx_flags_t;
+
+/**
+ * DRM_IOCTL_ADD_CTX ioctl argument type.
+ *
+ * \sa drmCreateContext() and drmDestroyContext().
+ */
+typedef struct drm_ctx {
+	drm_context_t handle;
+	drm_ctx_flags_t flags;
+} drm_ctx_t;
+
+/**
+ * DRM_IOCTL_RES_CTX ioctl argument type.
+ */
+typedef struct drm_ctx_res {
+	int count;
+	drm_ctx_t __user *contexts;
+} drm_ctx_res_t;
+
+
+/**
+ * DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type.
+ */
+typedef struct drm_draw {
+	drm_drawable_t handle;
+} drm_draw_t;
+
+/**
+ * DRM_IOCTL_UPDATE_DRAW ioctl argument type.
+ */
+typedef enum {
+         DRM_DRAWABLE_CLIPRECTS,
+} drm_drawable_info_type_t;
+
+typedef struct drm_update_draw {
+	drm_drawable_t handle;
+	unsigned int type;
+	unsigned int num;
+	unsigned long long data;
+} drm_update_draw_t;
+
+/**
+ * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
+ */
+typedef struct drm_auth {
+	drm_magic_t magic;
+} drm_auth_t;
+
+/**
+ * DRM_IOCTL_IRQ_BUSID ioctl argument type.
+ *
+ * \sa drmGetInterruptFromBusID().
+ */
+typedef struct drm_irq_busid {
+	int irq;	/**< IRQ number */
+	int busnum;	/**< bus number */
+	int devnum;	/**< device number */
+	int funcnum;	/**< function number */
+} drm_irq_busid_t;
+
+typedef enum {
+	_DRM_VBLANK_ABSOLUTE = 0x0,	/**< Wait for specific vblank sequence number */
+	_DRM_VBLANK_RELATIVE = 0x1,	/**< Wait for given number of vblanks */
+	_DRM_VBLANK_FLIP = 0x8000000,	/**< Scheduled buffer swap should flip */
+	_DRM_VBLANK_NEXTONMISS = 0x10000000,    /**< If missed, wait for next vblank */
+	_DRM_VBLANK_SECONDARY = 0x20000000,     /**< Secondary display controller */
+	_DRM_VBLANK_SIGNAL = 0x40000000	/**< Send signal instead of blocking */
+} drm_vblank_seq_type_t;
+
+#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE)
+#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL | _DRM_VBLANK_SECONDARY | \
+	_DRM_VBLANK_NEXTONMISS)
+
+struct drm_wait_vblank_request {
+	drm_vblank_seq_type_t type;
+	unsigned int sequence;
+	unsigned long signal;
+};
+
+struct drm_wait_vblank_reply {
+	drm_vblank_seq_type_t type;
+	unsigned int sequence;
+	long tval_sec;
+	long tval_usec;
+};
+
+/**
+ * DRM_IOCTL_WAIT_VBLANK ioctl argument type.
+ *
+ * \sa drmWaitVBlank().
+ */
+typedef union drm_wait_vblank {
+	struct drm_wait_vblank_request request;
+	struct drm_wait_vblank_reply reply;
+} drm_wait_vblank_t;
+
+/**
+ * DRM_IOCTL_AGP_ENABLE ioctl argument type.
+ *
+ * \sa drmAgpEnable().
+ */
+typedef struct drm_agp_mode {
+	unsigned long mode;	/**< AGP mode */
+} drm_agp_mode_t;
+
+/**
+ * DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type.
+ *
+ * \sa drmAgpAlloc() and drmAgpFree().
+ */
+typedef struct drm_agp_buffer {
+	unsigned long size;	/**< In bytes -- will round to page boundary */
+	unsigned long handle;	/**< Used for binding / unbinding */
+	unsigned long type;	/**< Type of memory to allocate */
+	unsigned long physical;	/**< Physical used by i810 */
+} drm_agp_buffer_t;
+
+/**
+ * DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type.
+ *
+ * \sa drmAgpBind() and drmAgpUnbind().
+ */
+typedef struct drm_agp_binding {
+	unsigned long handle;	/**< From drm_agp_buffer */
+	unsigned long offset;	/**< In bytes -- will round to page boundary */
+} drm_agp_binding_t;
+
+/**
+ * DRM_IOCTL_AGP_INFO ioctl argument type.
+ *
+ * \sa drmAgpVersionMajor(), drmAgpVersionMinor(), drmAgpGetMode(),
+ * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
+ * drmAgpVendorId() and drmAgpDeviceId().
+ */
+typedef struct drm_agp_info {
+	int agp_version_major;
+	int agp_version_minor;
+	unsigned long mode;
+	unsigned long aperture_base;   /**< physical address */
+	unsigned long aperture_size;   /**< bytes */
+	unsigned long memory_allowed;  /**< bytes */
+	unsigned long memory_used;
+
+	/** \name PCI information */
+	/*@{ */
+	unsigned short id_vendor;
+	unsigned short id_device;
+	/*@} */
+} drm_agp_info_t;
+
+/**
+ * DRM_IOCTL_SG_ALLOC ioctl argument type.
+ */
+typedef struct drm_scatter_gather {
+	unsigned long size;	/**< In bytes -- will round to page boundary */
+	unsigned long handle;	/**< Used for mapping / unmapping */
+} drm_scatter_gather_t;
+
+/**
+ * DRM_IOCTL_SET_VERSION ioctl argument type.
+ */
+typedef struct drm_set_version {
+	int drm_di_major;
+	int drm_di_minor;
+	int drm_dd_major;
+	int drm_dd_minor;
+} drm_set_version_t;
+
+/**
+ * \name Ioctls Definitions
+ */
+/*@{*/
+
+#define DRM_IOCTL_BASE			'd'
+#define DRM_IO(nr)			_IO(DRM_IOCTL_BASE,nr)
+#define DRM_IOR(nr,type)		_IOR(DRM_IOCTL_BASE,nr,type)
+#define DRM_IOW(nr,type)		_IOW(DRM_IOCTL_BASE,nr,type)
+#define DRM_IOWR(nr,type)		_IOWR(DRM_IOCTL_BASE,nr,type)
+
+#define DRM_IOCTL_VERSION		DRM_IOWR(0x00, drm_version_t)
+#define DRM_IOCTL_GET_UNIQUE		DRM_IOWR(0x01, drm_unique_t)
+#define DRM_IOCTL_GET_MAGIC		DRM_IOR( 0x02, drm_auth_t)
+#define DRM_IOCTL_IRQ_BUSID		DRM_IOWR(0x03, drm_irq_busid_t)
+#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, drm_map_t)
+#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, drm_client_t)
+#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, drm_stats_t)
+#define DRM_IOCTL_SET_VERSION		DRM_IOWR(0x07, drm_set_version_t)
+
+#define DRM_IOCTL_SET_UNIQUE		DRM_IOW( 0x10, drm_unique_t)
+#define DRM_IOCTL_AUTH_MAGIC		DRM_IOW( 0x11, drm_auth_t)
+#define DRM_IOCTL_BLOCK			DRM_IOWR(0x12, drm_block_t)
+#define DRM_IOCTL_UNBLOCK		DRM_IOWR(0x13, drm_block_t)
+#define DRM_IOCTL_CONTROL		DRM_IOW( 0x14, drm_control_t)
+#define DRM_IOCTL_ADD_MAP		DRM_IOWR(0x15, drm_map_t)
+#define DRM_IOCTL_ADD_BUFS		DRM_IOWR(0x16, drm_buf_desc_t)
+#define DRM_IOCTL_MARK_BUFS		DRM_IOW( 0x17, drm_buf_desc_t)
+#define DRM_IOCTL_INFO_BUFS		DRM_IOWR(0x18, drm_buf_info_t)
+#define DRM_IOCTL_MAP_BUFS		DRM_IOWR(0x19, drm_buf_map_t)
+#define DRM_IOCTL_FREE_BUFS		DRM_IOW( 0x1a, drm_buf_free_t)
+
+#define DRM_IOCTL_RM_MAP		DRM_IOW( 0x1b, drm_map_t)
+
+#define DRM_IOCTL_SET_SAREA_CTX		DRM_IOW( 0x1c, drm_ctx_priv_map_t)
+#define DRM_IOCTL_GET_SAREA_CTX 	DRM_IOWR(0x1d, drm_ctx_priv_map_t)
+
+#define DRM_IOCTL_ADD_CTX		DRM_IOWR(0x20, drm_ctx_t)
+#define DRM_IOCTL_RM_CTX		DRM_IOWR(0x21, drm_ctx_t)
+#define DRM_IOCTL_MOD_CTX		DRM_IOW( 0x22, drm_ctx_t)
+#define DRM_IOCTL_GET_CTX		DRM_IOWR(0x23, drm_ctx_t)
+#define DRM_IOCTL_SWITCH_CTX		DRM_IOW( 0x24, drm_ctx_t)
+#define DRM_IOCTL_NEW_CTX		DRM_IOW( 0x25, drm_ctx_t)
+#define DRM_IOCTL_RES_CTX		DRM_IOWR(0x26, drm_ctx_res_t)
+#define DRM_IOCTL_ADD_DRAW		DRM_IOWR(0x27, drm_draw_t)
+#define DRM_IOCTL_RM_DRAW		DRM_IOWR(0x28, drm_draw_t)
+#define DRM_IOCTL_DMA			DRM_IOWR(0x29, drm_dma_t)
+#define DRM_IOCTL_LOCK			DRM_IOW( 0x2a, drm_lock_t)
+#define DRM_IOCTL_UNLOCK		DRM_IOW( 0x2b, drm_lock_t)
+#define DRM_IOCTL_FINISH		DRM_IOW( 0x2c, drm_lock_t)
+
+#define DRM_IOCTL_AGP_ACQUIRE		DRM_IO(  0x30)
+#define DRM_IOCTL_AGP_RELEASE		DRM_IO(  0x31)
+#define DRM_IOCTL_AGP_ENABLE		DRM_IOW( 0x32, drm_agp_mode_t)
+#define DRM_IOCTL_AGP_INFO		DRM_IOR( 0x33, drm_agp_info_t)
+#define DRM_IOCTL_AGP_ALLOC		DRM_IOWR(0x34, drm_agp_buffer_t)
+#define DRM_IOCTL_AGP_FREE		DRM_IOW( 0x35, drm_agp_buffer_t)
+#define DRM_IOCTL_AGP_BIND		DRM_IOW( 0x36, drm_agp_binding_t)
+#define DRM_IOCTL_AGP_UNBIND		DRM_IOW( 0x37, drm_agp_binding_t)
+
+#define DRM_IOCTL_SG_ALLOC		DRM_IOW( 0x38, drm_scatter_gather_t)
+#define DRM_IOCTL_SG_FREE		DRM_IOW( 0x39, drm_scatter_gather_t)
+
+#define DRM_IOCTL_WAIT_VBLANK		DRM_IOWR(0x3a, drm_wait_vblank_t)
+
+#define DRM_IOCTL_UPDATE_DRAW           DRM_IOW(0x3f, drm_update_draw_t)
+/*@}*/
+
+/**
+ * Device specific ioctls should only be in their respective headers
+ * The device specific ioctl range is from 0x40 to 0x99.
+ * Generic IOCTLS restart at 0xA0.
+ *
+ * \sa drmCommandNone(), drmCommandRead(), drmCommandWrite(), and
+ * drmCommandReadWrite().
+ */
+#define DRM_COMMAND_BASE                0x40
+#define DRM_COMMAND_END                 0xA0
+
+#endif /* _DRM_H_ */
diff --git a/src/VBox/Additions/solaris/DRM/include/drmP.h b/src/VBox/Additions/solaris/DRM/include/drmP.h
new file mode 100644
index 00000000..0763e708
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/include/drmP.h
@@ -0,0 +1,908 @@
+/*
+ * drmP.h -- Private header for Direct Rendering Manager -*- linux-c -*-
+ * Created: Mon Jan  4 10:05:05 1999 by faith@precisioninsight.com
+ */
+/*
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All rights reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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.
+ *
+ * Authors:
+ *    Rickard E. (Rik) Faith <faith@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
+ *
+ */
+
+/*
+ * Copyright 2009-2010 Oracle Corporation
+ * All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_DRMP_H
+#define	_DRMP_H
+
+#include <sys/types.h>
+#include <sys/conf.h>
+#include <sys/modctl.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <sys/cmn_err.h>
+#include <sys/varargs.h>
+#include <sys/pci.h>
+#include <sys/ddi.h>
+#include <sys/sunddi.h>
+#include <sys/sunldi.h>
+#include <sys/pmem.h>
+#include <sys/agpgart.h>
+#include <sys/time.h>
+#include "drm_atomic.h"
+#include "drm.h"
+#if !defined(VBOX_WITH_SYSTEM_QUEUE_H)
+# include "queue.h"
+#endif
+#include "drm_linux_list.h"
+
+#ifndef __inline__
+#define	__inline__	inline
+#endif
+
+#if !defined(__FUNCTION__)
+#if defined(C99)
+#define	__FUNCTION__ __func__
+#else
+#define	__FUNCTION__	" "
+#endif
+#endif
+
+/* DRM space units */
+#define	DRM_PAGE_SHIFT			PAGESHIFT
+#define	DRM_PAGE_SIZE			(1 << DRM_PAGE_SHIFT)
+#define	DRM_PAGE_OFFSET			(DRM_PAGE_SIZE - 1)
+#define	DRM_PAGE_MASK			~(DRM_PAGE_SIZE - 1)
+#define	DRM_MB2PAGES(x)			((x) << 8)
+#define	DRM_PAGES2BYTES(x)		((x) << DRM_PAGE_SHIFT)
+#define	DRM_BYTES2PAGES(x)		((x) >> DRM_PAGE_SHIFT)
+#define	DRM_PAGES2KB(x)			((x) << 2)
+#define	DRM_ALIGNED(offset)		(((offset) & DRM_PAGE_OFFSET) == 0)
+
+#define	PAGE_SHIFT			DRM_PAGE_SHIFT
+#define	PAGE_SIZE			DRM_PAGE_SIZE
+
+#define	DRM_MAX_INSTANCES	8
+#define	DRM_DEVNODE		"drm"
+#define	DRM_UNOPENED		0
+#define	DRM_OPENED		1
+
+#define	DRM_HASH_SIZE		16 /* Size of key hash table */
+#define	DRM_KERNEL_CONTEXT	0  /* Change drm_resctx if changed */
+#define	DRM_RESERVED_CONTEXTS	1  /* Change drm_resctx if changed */
+
+#define	DRM_MEM_DMA	   0
+#define	DRM_MEM_SAREA	   1
+#define	DRM_MEM_DRIVER	   2
+#define	DRM_MEM_MAGIC	   3
+#define	DRM_MEM_IOCTLS	   4
+#define	DRM_MEM_MAPS	   5
+#define	DRM_MEM_BUFS	   6
+#define	DRM_MEM_SEGS	   7
+#define	DRM_MEM_PAGES	   8
+#define	DRM_MEM_FILES	  9
+#define	DRM_MEM_QUEUES	  10
+#define	DRM_MEM_CMDS	  11
+#define	DRM_MEM_MAPPINGS  12
+#define	DRM_MEM_BUFLISTS  13
+#define	DRM_MEM_DRMLISTS  14
+#define	DRM_MEM_TOTALDRM  15
+#define	DRM_MEM_BOUNDDRM  16
+#define	DRM_MEM_CTXBITMAP 17
+#define	DRM_MEM_STUB	  18
+#define	DRM_MEM_SGLISTS	  19
+#define	DRM_MEM_AGPLISTS  20
+#define	DRM_MEM_CTXLIST   21
+#define	DRM_MEM_MM		22
+#define	DRM_MEM_HASHTAB		23
+#define	DRM_MEM_OBJECTS		24
+
+#define	DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
+#define	DRM_MAP_HASH_OFFSET 0x10000000
+#define	DRM_MAP_HASH_ORDER 12
+#define	DRM_OBJECT_HASH_ORDER 12
+#define	DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
+#define	DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
+#define	DRM_MM_INIT_MAX_PAGES 256
+
+
+/* Internal types and structures */
+#define	DRM_ARRAY_SIZE(x) (sizeof (x) / sizeof (x[0]))
+#define	DRM_MIN(a, b) ((a) < (b) ? (a) : (b))
+#define	DRM_MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define	DRM_IF_VERSION(maj, min) (maj << 16 | min)
+
+#define	__OS_HAS_AGP	1
+
+#define	DRM_DEV_MOD	(S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
+#define	DRM_DEV_UID	0
+#define	DRM_DEV_GID	0
+
+#define	DRM_CURRENTPID		ddi_get_pid()
+#define	DRM_SPINLOCK(l)		mutex_enter(l)
+#define	DRM_SPINUNLOCK(u)	mutex_exit(u)
+#define	DRM_SPINLOCK_ASSERT(l)
+#define	DRM_LOCK()	mutex_enter(&dev->dev_lock)
+#define	DRM_UNLOCK()	mutex_exit(&dev->dev_lock)
+#define	DRM_LOCK_OWNED()	ASSERT(mutex_owned(&dev->dev_lock))
+#define	spin_lock_irqsave(l, flag)		mutex_enter(l)
+#define	spin_unlock_irqrestore(u, flag) mutex_exit(u)
+#define	spin_lock(l)		mutex_enter(l)
+#define	spin_unlock(u)		mutex_exit(u)
+
+#define	DRM_UDELAY(sec)  delay(drv_usectohz(sec *1000))
+#define	DRM_MEMORYBARRIER()
+
+typedef	struct drm_file		drm_file_t;
+typedef struct drm_device	drm_device_t;
+typedef struct drm_driver_info drm_driver_t;
+
+#define	DRM_DEVICE	drm_device_t *dev = dev1
+#define	DRM_IOCTL_ARGS	\
+	drm_device_t *dev1, intptr_t data, drm_file_t *fpriv, int mode
+
+#define	DRM_COPYFROM_WITH_RETURN(dest, src, size)	\
+	if (ddi_copyin(src, dest, size, 0)) \
+		return (EFAULT)
+
+#define	DRM_COPYTO_WITH_RETURN(dest, src, size)	\
+	if (ddi_copyout((src), (dest), (size), 0)) \
+		return (EFAULT)
+
+#define	DRM_COPY_FROM_USER(dest, src, size) \
+	ddi_copyin((src), (dest), (size), 0) /* flag for src */
+
+#define	DRM_COPY_TO_USER(dest, src, size) \
+	ddi_copyout((src), (dest), (size), 0) /* flags for dest */
+
+#define	DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3)  \
+	ddi_copyin((arg2), (arg1), (arg3), 0)
+
+#define	DRM_COPY_TO_USER_UNCHECKED(arg1, arg2, arg3)        \
+	ddi_copyout((arg2), arg1, arg3, 0)
+
+#define	DRM_READ8(map, offset) \
+	*(uint8_t *)((uintptr_t)((map)->dev_addr) + (offset))
+#define	DRM_READ16(map, offset) \
+	*(uint16_t *)((uintptr_t)((map)->dev_addr) + (offset))
+#define	DRM_READ32(map, offset) \
+	*(uint32_t *)((uintptr_t)((map)->dev_addr) + (offset))
+#define	DRM_WRITE8(map, offset, val) \
+	*(uint8_t *)((uintptr_t)((map)->dev_addr) + (offset)) = (val)
+#define	DRM_WRITE16(map, offset, val) \
+	*(uint16_t *)((uintptr_t)((map)->dev_addr) + (offset)) = (val)
+#define	DRM_WRITE32(map, offset, val) \
+	*(uint32_t *)((uintptr_t)((map)->dev_addr) + (offset)) = (val)
+
+typedef struct drm_wait_queue {
+	kcondvar_t	cv;
+	kmutex_t	lock;
+}wait_queue_head_t;
+
+#define	DRM_INIT_WAITQUEUE(q, pri)	\
+{ \
+	mutex_init(&(q)->lock, NULL, MUTEX_DRIVER, pri); \
+	cv_init(&(q)->cv, NULL, CV_DRIVER, NULL);	\
+}
+
+#define	DRM_FINI_WAITQUEUE(q)	\
+{ \
+	mutex_destroy(&(q)->lock);	\
+	cv_destroy(&(q)->cv);	\
+}
+
+#define	DRM_WAKEUP(q)	\
+{ \
+	mutex_enter(&(q)->lock); \
+	cv_broadcast(&(q)->cv);	\
+	mutex_exit(&(q)->lock);	\
+}
+
+#define	jiffies			ddi_get_lbolt()
+#define	DRM_WAIT_ON(ret, q, timeout, condition)  \
+mutex_enter(&(q)->lock);	\
+while (!(condition)) {	\
+	ret = cv_timedwait_sig(&(q)->cv, &(q)->lock, jiffies + timeout); \
+	if (ret == -1) {					\
+		ret = EBUSY;				\
+		break;					\
+	} else if (ret == 0) {				\
+		ret = EINTR;  \
+		break; \
+	} else { \
+		ret = 0; \
+	} \
+} \
+mutex_exit(&(q)->lock);
+
+#define	DRM_GETSAREA()  					\
+{                                				\
+	drm_local_map_t *map;					\
+	DRM_SPINLOCK_ASSERT(&dev->dev_lock);			\
+	TAILQ_FOREACH(map, &dev->maplist, link) {		\
+		if (map->type == _DRM_SHM &&			\
+			map->flags & _DRM_CONTAINS_LOCK) {	\
+			dev_priv->sarea = map;			\
+			break;					\
+		}						\
+	}							\
+}
+
+#define	LOCK_TEST_WITH_RETURN(dev, fpriv)				\
+	if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) ||		\
+	    dev->lock.filp != fpriv) {					\
+		DRM_ERROR("called without lock held");	\
+		return (EINVAL);					\
+	}
+
+#define	DRM_IRQ_ARGS	caddr_t arg
+#define	IRQ_HANDLED		DDI_INTR_CLAIMED
+#define	IRQ_NONE		DDI_INTR_UNCLAIMED
+
+enum {
+	DRM_IS_NOT_AGP,
+	DRM_IS_AGP,
+	DRM_MIGHT_BE_AGP
+};
+
+/* Capabilities taken from src/sys/dev/pci/pcireg.h. */
+#ifndef PCIY_AGP
+#define	PCIY_AGP		0x02
+#endif
+
+#ifndef PCIY_EXPRESS
+#define	PCIY_EXPRESS		0x10
+#endif
+
+#define	PAGE_ALIGN(addr)	(((addr) + DRM_PAGE_SIZE - 1) & DRM_PAGE_MASK)
+#define	DRM_SUSER(p)		(crgetgid(p) == 0 || crgetuid(p) == 0)
+
+/*
+ * wait for 400 milliseconds
+ */
+#define	DRM_HZ			drv_usectohz(400000)
+
+typedef unsigned long dma_addr_t;
+typedef uint64_t	u64;
+typedef uint32_t	u32;
+typedef uint16_t	u16;
+typedef uint8_t		u8;
+typedef uint_t		irqreturn_t;
+
+#define	DRM_SUPPORT	1
+#define	DRM_UNSUPPORT	0
+
+#define	__OS_HAS_AGP	1
+
+#define	__offsetof(type, field) ((size_t)(&((type *)0)->field))
+#define	offsetof(type, field)   __offsetof(type, field)
+
+typedef struct drm_pci_id_list
+{
+	int vendor;
+	int device;
+	long driver_private;
+	char *name;
+} drm_pci_id_list_t;
+
+#define	DRM_AUTH	0x1
+#define	DRM_MASTER	0x2
+#define	DRM_ROOT_ONLY	0x4
+typedef int drm_ioctl_t(DRM_IOCTL_ARGS);
+typedef struct drm_ioctl_desc {
+	int	(*func)(DRM_IOCTL_ARGS);
+	int	flags;
+} drm_ioctl_desc_t;
+
+typedef struct drm_magic_entry {
+	drm_magic_t		magic;
+	struct drm_file		*priv;
+	struct drm_magic_entry	*next;
+} drm_magic_entry_t;
+
+typedef struct drm_magic_head {
+	struct drm_magic_entry *head;
+	struct drm_magic_entry *tail;
+} drm_magic_head_t;
+
+typedef struct drm_buf {
+	int		idx;		/* Index into master buflist */
+	int		total;		/* Buffer size */
+	int		order;		/* log-base-2(total) */
+	int		used;		/* Amount of buffer in use (for DMA) */
+	unsigned long	offset;		/* Byte offset (used internally) */
+	void		*address;	/* Address of buffer */
+	unsigned long	bus_address;	/* Bus address of buffer */
+	struct drm_buf	*next;		/* Kernel-only: used for free list */
+	volatile int	pending;	/* On hardware DMA queue */
+	drm_file_t		*filp;
+				/* Uniq. identifier of holding process */
+	int		context;	/* Kernel queue for this buffer */
+	enum {
+		DRM_LIST_NONE	 = 0,
+		DRM_LIST_FREE	 = 1,
+		DRM_LIST_WAIT	 = 2,
+		DRM_LIST_PEND	 = 3,
+		DRM_LIST_PRIO	 = 4,
+		DRM_LIST_RECLAIM = 5
+	}		list;		/* Which list we're on */
+
+	int		dev_priv_size;	/* Size of buffer private storage */
+	void		*dev_private;	/* Per-buffer private storage */
+} drm_buf_t;
+
+typedef struct drm_freelist {
+	int		  initialized;	/* Freelist in use		*/
+	uint32_t	  count;	/* Number of free buffers	*/
+	drm_buf_t	  *next;	/* End pointer			*/
+
+	int		  low_mark;	/* Low water mark		*/
+	int		  high_mark;	/* High water mark		*/
+} drm_freelist_t;
+
+typedef struct drm_buf_entry {
+	int		  buf_size;
+	int		  buf_count;
+	drm_buf_t	  *buflist;
+	int		  seg_count;
+	int		  page_order;
+
+	uint32_t	  *seglist;
+	unsigned long	  *seglist_bus;
+
+	drm_freelist_t	  freelist;
+} drm_buf_entry_t;
+
+typedef TAILQ_HEAD(drm_file_list, drm_file) drm_file_list_t;
+struct drm_file {
+	TAILQ_ENTRY(drm_file) link;
+	int		  authenticated;
+	int		  master;
+	int		  minor;
+	pid_t		  pid;
+	uid_t		  uid;
+	int		  refs;
+	drm_magic_t	  magic;
+	unsigned long	  ioctl_count;
+	void		 *driver_priv;
+};
+
+typedef struct drm_lock_data {
+	drm_hw_lock_t	*hw_lock;	/* Hardware lock		*/
+	drm_file_t	*filp;
+	/* Uniq. identifier of holding process */
+	kcondvar_t	lock_cv;	/* lock queue - SOLARIS Specific */
+	kmutex_t	lock_mutex;	/* lock - SOLARIS Specific */
+	unsigned long	lock_time;	/* Time of last lock in jiffies */
+} drm_lock_data_t;
+
+/*
+ * This structure, in drm_device_t, is always initialized while the device
+ * is open.  dev->dma_lock protects the incrementing of dev->buf_use, which
+ * when set marks that no further bufs may be allocated until device teardown
+ * occurs (when the last open of the device has closed).  The high/low
+ * watermarks of bufs are only touched by the X Server, and thus not
+ * concurrently accessed, so no locking is needed.
+ */
+typedef struct drm_device_dma {
+	drm_buf_entry_t	bufs[DRM_MAX_ORDER+1];
+	int		buf_count;
+	drm_buf_t	**buflist;	/* Vector of pointers info bufs	   */
+	int		seg_count;
+	int		page_count;
+	unsigned long	*pagelist;
+	unsigned long	byte_count;
+	enum {
+		_DRM_DMA_USE_AGP = 0x01,
+		_DRM_DMA_USE_SG  = 0x02
+	} flags;
+} drm_device_dma_t;
+
+typedef struct drm_agp_mem {
+	void		*handle;
+	unsigned long	bound; /* address */
+	int		pages;
+	caddr_t		phys_addr;
+	struct drm_agp_mem *prev;
+	struct drm_agp_mem *next;
+} drm_agp_mem_t;
+
+typedef struct drm_agp_head {
+	agp_info_t	agp_info;
+	const char	*chipset;
+	drm_agp_mem_t	*memory;
+	unsigned long	mode;
+	int		enabled;
+	int		acquired;
+	unsigned long	base;
+	int		mtrr;
+	int		cant_use_aperture;
+	unsigned long	page_mask;
+	ldi_ident_t	agpgart_li;
+	ldi_handle_t	agpgart_lh;
+} drm_agp_head_t;
+
+
+typedef struct drm_dma_handle {
+	ddi_dma_handle_t	dma_hdl;
+	ddi_acc_handle_t	acc_hdl;
+	ddi_dma_cookie_t	cookie;
+	uint_t		cookie_num;
+	uintptr_t		vaddr;   /* virtual addr */
+	uintptr_t		paddr;   /* physical addr */
+	size_t		real_sz; /* real size of memory */
+} drm_dma_handle_t;
+
+typedef struct drm_sg_mem {
+	unsigned long	handle;
+	void		*virtual;
+	int		pages;
+	dma_addr_t  	*busaddr;
+	ddi_umem_cookie_t	*umem_cookie;
+	drm_dma_handle_t	*dmah_sg;
+	drm_dma_handle_t	*dmah_gart; /* Handle to PCI memory */
+} drm_sg_mem_t;
+
+typedef TAILQ_HEAD(drm_map_list, drm_local_map) drm_map_list_t;
+
+/* BEGIN CSTYLED */
+typedef struct drm_local_map {
+	unsigned long	offset;  /*  Physical address (0 for SAREA)	*/
+	unsigned long	size;	 /* Physical size (bytes)		*/
+	drm_map_type_t	type;	 /* Type of memory mapped		*/
+	drm_map_flags_t flags;	 /* Flags				*/
+	void		*handle; /* User-space: "Handle" to pass to mmap */
+				 /* Kernel-space: kernel-virtual address */
+	int		mtrr;	 /* Boolean: MTRR used 			*/
+				 /* Private data			*/
+	int		rid;	 /* PCI resource ID for bus_space 	*/
+	int		kernel_owned; /* Boolean: 1= initmapped, 0= addmapped */
+	caddr_t		dev_addr;	  /* base device address 	*/
+	ddi_acc_handle_t  dev_handle;	  /* The data access handle 	*/
+	ddi_umem_cookie_t drm_umem_cookie; /* For SAREA alloc and free  */
+	TAILQ_ENTRY(drm_local_map) link;
+} drm_local_map_t;
+/* END CSTYLED */
+
+typedef TAILQ_HEAD(drm_vbl_sig_list, drm_vbl_sig) drm_vbl_sig_list_t;
+typedef struct drm_vbl_sig {
+	TAILQ_ENTRY(drm_vbl_sig) link;
+	unsigned int	sequence;
+	int		signo;
+	int		pid;
+} drm_vbl_sig_t;
+
+
+/* used for clone device */
+typedef TAILQ_HEAD(drm_cminor_list, drm_cminor) drm_cminor_list_t;
+typedef struct drm_cminor {
+	TAILQ_ENTRY(drm_cminor) link;
+	drm_file_t		*fpriv;
+	int			minor;
+} drm_cminor_t;
+
+/* location of GART table */
+#define	DRM_ATI_GART_MAIN	1
+#define	DRM_ATI_GART_FB		2
+
+typedef struct ati_pcigart_info {
+	int gart_table_location;
+	int is_pcie;
+	void *addr;
+	dma_addr_t bus_addr;
+	drm_local_map_t mapping;
+} drm_ati_pcigart_info;
+
+/* DRM device structure */
+struct drm_device;
+struct drm_driver_info {
+	int (*load)(struct drm_device *, unsigned long);
+	int (*firstopen)(struct drm_device *);
+	int (*open)(struct drm_device *, drm_file_t *);
+	void (*preclose)(struct drm_device *, drm_file_t *);
+	void (*postclose)(struct drm_device *, drm_file_t *);
+	void (*lastclose)(struct drm_device *);
+	int (*unload)(struct drm_device *);
+	void (*reclaim_buffers_locked)(struct drm_device *, drm_file_t *);
+	int (*presetup)(struct drm_device *);
+	int (*postsetup)(struct drm_device *);
+	int (*open_helper)(struct drm_device *, drm_file_t *);
+	void (*free_filp_priv)(struct drm_device *, drm_file_t *);
+	void (*release)(struct drm_device *, void *);
+	int (*dma_ioctl)(DRM_IOCTL_ARGS);
+	void (*dma_ready)(struct drm_device *);
+	int (*dma_quiescent)(struct drm_device *);
+	int (*dma_flush_block_and_flush)(struct drm_device *,
+			int, drm_lock_flags_t);
+	int (*dma_flush_unblock)(struct drm_device *, int,
+					drm_lock_flags_t);
+	int (*context_ctor)(struct drm_device *, int);
+	int (*context_dtor)(struct drm_device *, int);
+	int (*kernel_context_switch)(struct drm_device *, int, int);
+	int (*kernel_context_switch_unlock)(struct drm_device *);
+	int (*device_is_agp) (struct drm_device *);
+	int (*irq_preinstall)(struct drm_device *);
+	void (*irq_postinstall)(struct drm_device *);
+	void (*irq_uninstall)(struct drm_device *dev);
+	uint_t (*irq_handler)(DRM_IRQ_ARGS);
+	int (*vblank_wait)(struct drm_device *, unsigned int *);
+	int (*vblank_wait2)(struct drm_device *, unsigned int *);
+	/* added for intel minimized vblank */
+	u32 (*get_vblank_counter)(struct drm_device *dev, int crtc);
+	int (*enable_vblank)(struct drm_device *dev, int crtc);
+	void (*disable_vblank)(struct drm_device *dev, int crtc);
+
+	drm_ioctl_desc_t *driver_ioctls;
+	int	max_driver_ioctl;
+
+	int	buf_priv_size;
+	int	driver_major;
+	int	driver_minor;
+	int	driver_patchlevel;
+	const char *driver_name;	/* Simple driver name		   */
+	const char *driver_desc;	/* Longer driver name		   */
+	const char *driver_date;	/* Date of last major changes.	   */
+
+	unsigned use_agp :1;
+	unsigned require_agp :1;
+	unsigned use_sg :1;
+	unsigned use_dma :1;
+	unsigned use_pci_dma :1;
+	unsigned use_dma_queue :1;
+	unsigned use_irq :1;
+	unsigned use_vbl_irq :1;
+	unsigned use_vbl_irq2 :1;
+	unsigned use_mtrr :1;
+};
+
+/*
+ * hardware-specific code needs to initialize mutexes which
+ * can be used in interrupt context, so they need to know
+ * the interrupt priority. Interrupt cookie in drm_device
+ * structure is the intr_block field.
+ */
+#define	DRM_INTR_PRI(dev) \
+	DDI_INTR_PRI((dev)->intr_block)
+
+struct drm_device {
+	drm_driver_t	*driver;
+	drm_cminor_list_t	minordevs;
+	dev_info_t *dip;
+	void	*drm_handle;
+	int drm_supported;
+	const char *desc; /* current driver description */
+	kmutex_t *irq_mutex;
+	kcondvar_t *irq_cv;
+
+	ddi_iblock_cookie_t intr_block;
+	uint32_t	pci_device;	/* PCI device id */
+	uint32_t	pci_vendor;
+	char		*unique;	/* Unique identifier: e.g., busid  */
+	int		unique_len;	/* Length of unique field	   */
+	int		if_version;	/* Highest interface version set */
+	int		flags;	/* Flags to open(2)		   */
+
+	/* Locks */
+	kmutex_t	  vbl_lock;	/* protects vblank operations */
+	kmutex_t	  dma_lock;	/* protects dev->dma */
+	kmutex_t	  irq_lock;	/* protects irq condition checks */
+	kmutex_t	  dev_lock;	/* protects everything else */
+	drm_lock_data_t   lock;		/* Information on hardware lock    */
+
+	/* Usage Counters */
+	int		  open_count;	/* Outstanding files open	   */
+	int		  buf_use;	/* Buffers in use -- cannot alloc  */
+
+	/* Performance counters */
+	unsigned long	  counters;
+	drm_stat_type_t	  types[15];
+	uint32_t	  counts[15];
+
+	/* Authentication */
+	drm_file_list_t   files;
+	drm_magic_head_t  magiclist[DRM_HASH_SIZE];
+
+	/* Linked list of mappable regions. Protected by dev_lock */
+	drm_map_list_t	  maplist;
+
+	drm_local_map_t	  **context_sareas;
+	int		  max_context;
+
+	/* DMA queues (contexts) */
+	drm_device_dma_t  *dma;		/* Optional pointer for DMA support */
+
+	/* Context support */
+	int		  irq;		/* Interrupt used by board	   */
+	int		  irq_enabled;	/* True if the irq handler is enabled */
+	int		  pci_domain;
+	int		  pci_bus;
+	int		  pci_slot;
+	int		  pci_func;
+	atomic_t	  context_flag;	/* Context swapping flag	   */
+	int		  last_context;	/* Last current context		   */
+
+	/* Only used for Radeon */
+	atomic_t	vbl_received;
+	atomic_t	vbl_received2;
+
+	drm_vbl_sig_list_t vbl_sig_list;
+	drm_vbl_sig_list_t vbl_sig_list2;
+
+	wait_queue_head_t	vbl_queue;	/* vbl wait channel */
+	/* vbl wait channel array */
+	wait_queue_head_t	*vbl_queues;
+
+	/* number of VBLANK interrupts */
+	/* (driver must alloc the right number of counters) */
+	atomic_t	  *_vblank_count;
+	/* signal list to send on VBLANK */
+	struct drm_vbl_sig_list *vbl_sigs;
+
+	/* number of signals pending on all crtcs */
+	atomic_t	  vbl_signal_pending;
+	/* number of users of vblank interrupts per crtc */
+	atomic_t	  *vblank_refcount;
+	/* protected by dev->vbl_lock, used for wraparound handling */
+	u32		  *last_vblank;
+	/* so we don't call enable more than */
+	atomic_t	  *vblank_enabled;
+	/* for compensation of spurious wraparounds */
+	u32		  *vblank_premodeset;
+	/* Don't wait while crtc is likely disabled */
+	int		  *vblank_suspend;
+	/* size of vblank counter register */
+	u32		  max_vblank_count;
+	int		  num_crtcs;
+	kmutex_t	tasklet_lock;
+	void (*locked_tasklet_func)(struct drm_device *dev);
+
+	pid_t		  buf_pgid;
+	drm_agp_head_t    *agp;
+	drm_sg_mem_t	  *sg;  /* Scatter gather memory */
+	uint32_t	  *ctx_bitmap;
+	void		  *dev_private;
+	unsigned int	  agp_buffer_token;
+	drm_local_map_t   *agp_buffer_map;
+
+	kstat_t		  *asoft_ksp; /* kstat support */
+
+	/* name Drawable information */
+	kmutex_t	drw_lock;
+	unsigned int drw_bitfield_length;
+	u32 *drw_bitfield;
+	unsigned int drw_info_length;
+	drm_drawable_info_t **drw_info;
+	/*
+	 * Saving S3 context
+	 */
+	void		  *s3_private;
+};
+
+/* Memory management support (drm_memory.c) */
+void	drm_mem_init(void);
+void	drm_mem_uninit(void);
+void	*drm_alloc(size_t, int);
+void	*drm_calloc(size_t, size_t, int);
+void	*drm_realloc(void *, size_t, size_t, int);
+void	drm_free(void *, size_t, int);
+int 	drm_ioremap(drm_device_t *, drm_local_map_t *);
+void	drm_ioremapfree(drm_local_map_t *);
+
+void drm_core_ioremap(struct drm_local_map *, struct drm_device *);
+void drm_core_ioremapfree(struct drm_local_map *, struct drm_device *);
+
+void drm_pci_free(drm_device_t *, drm_dma_handle_t *);
+void *drm_pci_alloc(drm_device_t *, size_t, size_t, dma_addr_t, int);
+
+struct drm_local_map *drm_core_findmap(struct drm_device *, unsigned long);
+
+int	drm_context_switch(drm_device_t *, int, int);
+int	drm_context_switch_complete(drm_device_t *, int);
+int	drm_ctxbitmap_init(drm_device_t *);
+void	drm_ctxbitmap_cleanup(drm_device_t *);
+void	drm_ctxbitmap_free(drm_device_t *, int);
+int	drm_ctxbitmap_next(drm_device_t *);
+
+/* Locking IOCTL support (drm_lock.c) */
+int	drm_lock_take(drm_lock_data_t *, unsigned int);
+int	drm_lock_transfer(drm_device_t *,
+			drm_lock_data_t *, unsigned int);
+int	drm_lock_free(drm_device_t *,
+		    volatile unsigned int *, unsigned int);
+
+/* Buffer management support (drm_bufs.c) */
+unsigned long drm_get_resource_start(drm_device_t *, unsigned int);
+unsigned long drm_get_resource_len(drm_device_t *, unsigned int);
+int	drm_initmap(drm_device_t *, unsigned long, unsigned long,
+    unsigned int, int, int);
+void	drm_rmmap(drm_device_t *, drm_local_map_t *);
+int	drm_addmap(drm_device_t *, unsigned long, unsigned long,
+    drm_map_type_t, drm_map_flags_t, drm_local_map_t **);
+int	drm_order(unsigned long);
+
+/* DMA support (drm_dma.c) */
+int	drm_dma_setup(drm_device_t *);
+void	drm_dma_takedown(drm_device_t *);
+void	drm_free_buffer(drm_device_t *, drm_buf_t *);
+void	drm_reclaim_buffers(drm_device_t *, drm_file_t *);
+#define	drm_core_reclaim_buffers	drm_reclaim_buffers
+
+/* IRQ support (drm_irq.c) */
+int	drm_irq_install(drm_device_t *);
+int	drm_irq_uninstall(drm_device_t *);
+uint_t	drm_irq_handler(DRM_IRQ_ARGS);
+void	drm_driver_irq_preinstall(drm_device_t *);
+void	drm_driver_irq_postinstall(drm_device_t *);
+void	drm_driver_irq_uninstall(drm_device_t *);
+int	drm_vblank_wait(drm_device_t *, unsigned int *);
+void	drm_vbl_send_signals(drm_device_t *);
+void    drm_handle_vblank(struct drm_device *dev, int crtc);
+u32	drm_vblank_count(struct drm_device *dev, int crtc);
+int	drm_vblank_get(struct drm_device *dev, int crtc);
+void	drm_vblank_put(struct drm_device *dev, int crtc);
+int	drm_vblank_init(struct drm_device *dev, int num_crtcs);
+void    drm_locked_tasklet(drm_device_t *, void(*func)(drm_device_t *));
+
+/* AGP/GART support (drm_agpsupport.c) */
+int	drm_device_is_agp(drm_device_t *);
+int 	drm_device_is_pcie(drm_device_t *);
+drm_agp_head_t *drm_agp_init(drm_device_t *);
+void	drm_agp_fini(drm_device_t *);
+int 	drm_agp_do_release(drm_device_t *);
+void	*drm_agp_allocate_memory(size_t, uint32_t);
+int	drm_agp_free_memory(void *);
+int	drm_agp_bind_memory(unsigned int, uint32_t, drm_device_t *);
+int	drm_agp_unbind_memory(unsigned long, drm_device_t *);
+
+/* kstat support (drm_kstats.c) */
+int	drm_init_kstats(drm_device_t *);
+void	drm_fini_kstats(drm_device_t *);
+
+/* Scatter Gather Support (drm_scatter.c) */
+void	drm_sg_cleanup(drm_device_t *, drm_sg_mem_t *);
+
+/* ATI PCIGART support (ati_pcigart.c) */
+int	drm_ati_pcigart_init(drm_device_t *, drm_ati_pcigart_info *);
+int	drm_ati_pcigart_cleanup(drm_device_t *, drm_ati_pcigart_info *);
+
+/* Locking IOCTL support (drm_drv.c) */
+int	drm_lock(DRM_IOCTL_ARGS);
+int	drm_unlock(DRM_IOCTL_ARGS);
+int	drm_version(DRM_IOCTL_ARGS);
+int	drm_setversion(DRM_IOCTL_ARGS);
+
+/* Misc. IOCTL support (drm_ioctl.c) */
+int	drm_irq_by_busid(DRM_IOCTL_ARGS);
+int	drm_getunique(DRM_IOCTL_ARGS);
+int	drm_setunique(DRM_IOCTL_ARGS);
+int	drm_getmap(DRM_IOCTL_ARGS);
+int	drm_getclient(DRM_IOCTL_ARGS);
+int	drm_getstats(DRM_IOCTL_ARGS);
+int	drm_noop(DRM_IOCTL_ARGS);
+
+/* Context IOCTL support (drm_context.c) */
+int	drm_resctx(DRM_IOCTL_ARGS);
+int	drm_addctx(DRM_IOCTL_ARGS);
+int	drm_modctx(DRM_IOCTL_ARGS);
+int	drm_getctx(DRM_IOCTL_ARGS);
+int	drm_switchctx(DRM_IOCTL_ARGS);
+int	drm_newctx(DRM_IOCTL_ARGS);
+int	drm_rmctx(DRM_IOCTL_ARGS);
+int	drm_setsareactx(DRM_IOCTL_ARGS);
+int	drm_getsareactx(DRM_IOCTL_ARGS);
+
+/* Drawable IOCTL support (drm_drawable.c) */
+int	drm_adddraw(DRM_IOCTL_ARGS);
+int	drm_rmdraw(DRM_IOCTL_ARGS);
+int	drm_update_draw(DRM_IOCTL_ARGS);
+
+/* Authentication IOCTL support (drm_auth.c) */
+int	drm_getmagic(DRM_IOCTL_ARGS);
+int	drm_authmagic(DRM_IOCTL_ARGS);
+int	drm_remove_magic(drm_device_t *, drm_magic_t);
+drm_file_t	*drm_find_file(drm_device_t *, drm_magic_t);
+/* Buffer management support (drm_bufs.c) */
+int	drm_addmap_ioctl(DRM_IOCTL_ARGS);
+int	drm_rmmap_ioctl(DRM_IOCTL_ARGS);
+int	drm_addbufs_ioctl(DRM_IOCTL_ARGS);
+int	drm_infobufs(DRM_IOCTL_ARGS);
+int	drm_markbufs(DRM_IOCTL_ARGS);
+int	drm_freebufs(DRM_IOCTL_ARGS);
+int	drm_mapbufs(DRM_IOCTL_ARGS);
+
+/* DMA support (drm_dma.c) */
+int	drm_dma(DRM_IOCTL_ARGS);
+
+/* IRQ support (drm_irq.c) */
+int	drm_control(DRM_IOCTL_ARGS);
+int	drm_wait_vblank(DRM_IOCTL_ARGS);
+
+/* AGP/GART support (drm_agpsupport.c) */
+int	drm_agp_acquire(DRM_IOCTL_ARGS);
+int	drm_agp_release(DRM_IOCTL_ARGS);
+int	drm_agp_enable(DRM_IOCTL_ARGS);
+int	drm_agp_info(DRM_IOCTL_ARGS);
+int	drm_agp_alloc(DRM_IOCTL_ARGS);
+int	drm_agp_free(DRM_IOCTL_ARGS);
+int	drm_agp_unbind(DRM_IOCTL_ARGS);
+int	drm_agp_bind(DRM_IOCTL_ARGS);
+
+/* Scatter Gather Support (drm_scatter.c) */
+int	drm_sg_alloc(DRM_IOCTL_ARGS);
+int	drm_sg_free(DRM_IOCTL_ARGS);
+
+extern int drm_debug_flag;
+
+
+/* We add function to support DRM_DEBUG,DRM_ERROR,DRM_INFO */
+extern void drm_debug(const char *fmt, ...);
+extern void drm_error(const char *fmt, ...);
+extern void drm_info(const char *fmt, ...);
+
+#ifdef DEBUG
+#define	DRM_DEBUG		if (drm_debug_flag >= 2) drm_debug
+#define	DRM_INFO		if (drm_debug_flag >= 1) drm_info
+#else
+#define	DRM_DEBUG(...)
+#define	DRM_INFO(...)
+#endif
+
+#define	DRM_ERROR		drm_error
+
+
+#define	MAX_INSTNUMS 16
+
+extern int drm_dev_to_instance(dev_t);
+extern int drm_dev_to_minor(dev_t);
+extern void *drm_supp_register(dev_info_t *, drm_device_t *);
+extern int drm_supp_unregister(void *);
+
+extern int drm_open(drm_device_t *, drm_cminor_t *, int, int, cred_t *);
+extern int drm_close(drm_device_t *, int, int, int, cred_t *);
+extern int drm_attach(drm_device_t *);
+extern int drm_detach(drm_device_t *);
+extern int drm_probe(drm_device_t *, drm_pci_id_list_t *);
+
+extern int drm_pci_init(drm_device_t *);
+extern void drm_pci_end(drm_device_t *);
+extern int pci_get_info(drm_device_t *, int *, int *, int *);
+extern int pci_get_irq(drm_device_t *);
+extern int pci_get_vendor(drm_device_t *);
+extern int pci_get_device(drm_device_t *);
+
+extern struct drm_drawable_info *drm_get_drawable_info(drm_device_t *,
+							drm_drawable_t);
+/* File Operations helpers (drm_fops.c) */
+extern drm_file_t *drm_find_file_by_proc(drm_device_t *, cred_t *);
+extern drm_cminor_t *drm_find_file_by_minor(drm_device_t *, int);
+extern int drm_open_helper(drm_device_t *, drm_cminor_t *, int, int,
+    cred_t *);
+
+#endif	/* _DRMP_H */
diff --git a/src/VBox/Additions/solaris/DRM/include/drm_atomic.h b/src/VBox/Additions/solaris/DRM/include/drm_atomic.h
new file mode 100644
index 00000000..05401cc4
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/include/drm_atomic.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2010 Oracle Corporation
+ * All rights reserved.
+ * Use is subject to license terms.
+ */
+/*
+ * \file drm_atomic.h
+ * Atomic operations used in the DRM which may or may not be provided by the OS.
+ *
+ * \author Eric Anholt <anholt@FreeBSD.org>
+ */
+
+/*
+ * Copyright 2004 Eric Anholt
+ * All Rights Reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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.
+ */
+
+/* Many of these implementations are rather fake, but good enough. */
+
+
+
+#ifndef	_SYS_DRM_ATOMIC_H_
+#define	_SYS_DRM_ATOMIC_H_
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#include <sys/atomic.h>
+
+#ifdef __LINT__
+#undef inline
+#define	inline
+#endif
+typedef uint32_t	atomic_t;
+
+#define	atomic_set(p, v)	(*(p) = (v))
+#define	atomic_read(p)		(*(p))
+#define	atomic_inc(p)		atomic_add_int(p, 1)
+#define	atomic_dec(p)		atomic_dec_uint(p)
+#define	atomic_add(n, p)	atomic_add_int(p, n)
+#define	atomic_sub(n, p)	atomic_dec_uint(p, n)
+#define	atomic_set_int(p, bits)	atomic_or_uint(p, bits)
+#define	atomic_clear_int(p, bits)	atomic_and_uint(p, ~(bits))
+#define	atomic_cmpset_int(p, c, n) \
+	((c == atomic_cas_uint(p, c, n)) ? 1 : 0)
+
+#define	set_bit(b, p) \
+	atomic_set_int(((volatile uint_t *)(void *)p) + (b >> 5), \
+	1 << (b & 0x1f))
+
+#define	clear_bit(b, p) \
+	atomic_clear_int(((volatile uint_t *)(void *)p) + (b >> 5), \
+	1 << (b & 0x1f))
+
+#define	test_bit(b, p) \
+	(((volatile uint_t *)(void *)p)[b >> 5] & (1 << (b & 0x1f)))
+
+/*
+ * Note: this routine doesn't return old value. It return
+ * 0 when succeeds, or -1 when fails.
+ */
+#ifdef _LP64
+#define	test_and_set_bit(b, p) \
+	atomic_set_long_excl(((ulong_t *)(void *)p) + (b >> 6), (b & 0x3f))
+#else
+#define	test_and_set_bit(b, p) \
+	atomic_set_long_excl(((ulong_t *)(void *)p) + (b >> 5), (b & 0x1f))
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _SYS_DRM_ATOMIC_H_ */
diff --git a/src/VBox/Additions/solaris/DRM/include/drm_linux_list.h b/src/VBox/Additions/solaris/DRM/include/drm_linux_list.h
new file mode 100644
index 00000000..e811c9fe
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/include/drm_linux_list.h
@@ -0,0 +1,71 @@
+/*
+ * drm_linux_list.h -- linux list functions for the BSDs.
+ * Created: Mon Apr 7 14:30:16 1999 by anholt@FreeBSD.org
+ */
+/*
+ * -
+ * Copyright 2003 Eric Anholt
+ * All Rights Reserved.
+ *
+ * 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 (including the next
+ * paragraph) 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
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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.
+ *
+ * Authors:
+ *    Eric Anholt <anholt@FreeBSD.org>
+ *
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#ifndef _DRM_LINUX_LIST_H_
+#define	_DRM_LINUX_LIST_H_
+
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+/* Cheat, assume the list_head is at the start of the struct */
+#define	list_entry(entry, type, member)	(type *)(entry)
+
+#define	INIT_LIST_HEAD(head) { \
+	(head)->next = head;   \
+	(head)->prev = head;   \
+}
+
+#define	list_add_tail(entry, head) {  \
+	(entry)->prev = (head)->prev; \
+	(entry)->next = head;         \
+	(head)->prev->next = entry;   \
+	(head)->prev = entry;         \
+}
+
+#define	list_del(entry) {                         \
+	(entry)->next->prev = (entry)->prev;      \
+	(entry)->prev->next = (entry)->next;      \
+}
+
+#define	list_for_each(entry, head)				\
+    for (entry = (head)->next; entry != head; entry = (entry)->next)
+
+#define	list_for_each_safe(entry, temp, head)			\
+    for (entry = (head)->next, temp = (entry)->next;		\
+	temp != head; 						\
+	entry = temp, temp = temp->next)
+
+#endif /* _DRM_LINUX_LIST_H_ */
diff --git a/src/VBox/Additions/solaris/DRM/include/queue.h b/src/VBox/Additions/solaris/DRM/include/queue.h
new file mode 100644
index 00000000..4994209e
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/include/queue.h
@@ -0,0 +1,585 @@
+/* BEGIN CSTYLED */
+/*-
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
+ * $FreeBSD: /repoman/r/ncvs/src/sys/sys/queue.h,v 1.66 2006/05/26 18:17:53 emaste Exp $
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define	_SYS_QUEUE_H_
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+/*
+ * This file defines four types of data structures: singly-linked lists,
+ * singly-linked tail queues, lists and tail queues.
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A singly-linked tail queue is headed by a pair of pointers, one to the
+ * head of the list and the other to the tail of the list. The elements are
+ * singly linked for minimum space and pointer manipulation overhead at the
+ * expense of O(n) removal for arbitrary elements. New elements can be added
+ * to the list after an existing element, at the head of the list, or at the
+ * end of the list. Elements being removed from the head of the tail queue
+ * should use the explicit macro for this purpose for optimum efficiency.
+ * A singly-linked tail queue may only be traversed in the forward direction.
+ * Singly-linked tail queues are ideal for applications with large datasets
+ * and few or no removals or for implementing a FIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ *
+ *
+ *				SLIST	LIST	STAILQ	TAILQ
+ * _HEAD			+	+	+	+
+ * _HEAD_INITIALIZER		+	+	+	+
+ * _ENTRY			+	+	+	+
+ * _INIT			+	+	+	+
+ * _EMPTY			+	+	+	+
+ * _FIRST			+	+	+	+
+ * _NEXT			+	+	+	+
+ * _PREV			-	-	-	+
+ * _LAST			-	-	+	+
+ * _FOREACH			+	+	+	+
+ * _FOREACH_SAFE		+	+	+	+
+ * _FOREACH_REVERSE		-	-	-	+
+ * _FOREACH_REVERSE_SAFE	-	-	-	+
+ * _INSERT_HEAD			+	+	+	+
+ * _INSERT_BEFORE		-	+	-	+
+ * _INSERT_AFTER		+	+	+	+
+ * _INSERT_TAIL			-	-	+	+
+ * _CONCAT			-	-	+	+
+ * _REMOVE_HEAD			+	-	+	-
+ * _REMOVE			+	+	+	+
+ *
+ */
+#ifdef QUEUE_MACRO_DEBUG
+/* Store the last 2 places the queue element or head was altered */
+struct qm_trace {
+	char * lastfile;
+	int lastline;
+	char * prevfile;
+	int prevline;
+};
+
+#define	TRACEBUF	struct qm_trace trace;
+#define	TRASHIT(x)	do {(x) = (void *)-1;} while (*"\0")
+
+#define	QMD_TRACE_HEAD(head) do {					\
+	(head)->trace.prevline = (head)->trace.lastline;		\
+	(head)->trace.prevfile = (head)->trace.lastfile;		\
+	(head)->trace.lastline = __LINE__;				\
+	(head)->trace.lastfile = __FILE__;				\
+} while (*"\0")
+
+#define	QMD_TRACE_ELEM(elem) do {					\
+	(elem)->trace.prevline = (elem)->trace.lastline;		\
+	(elem)->trace.prevfile = (elem)->trace.lastfile;		\
+	(elem)->trace.lastline = __LINE__;				\
+	(elem)->trace.lastfile = __FILE__;				\
+} while (*"\0")
+
+#else
+#define	QMD_TRACE_ELEM(elem)
+#define	QMD_TRACE_HEAD(head)
+#define	TRACEBUF
+#define	TRASHIT(x)
+#endif	/* QUEUE_MACRO_DEBUG */
+
+/*
+ * Singly-linked List declarations.
+ */
+#define	SLIST_HEAD(name, type)						\
+struct name {								\
+	struct type *slh_first;	/* first element */			\
+}
+
+#define	SLIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#define	SLIST_ENTRY(type)						\
+struct {								\
+	struct type *sle_next;	/* next element */			\
+}
+
+/*
+ * Singly-linked List functions.
+ */
+#define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
+
+#define	SLIST_FIRST(head)	((head)->slh_first)
+
+#define	SLIST_FOREACH(var, head, field)					\
+	for ((var) = SLIST_FIRST((head));				\
+	    (var);							\
+	    (var) = SLIST_NEXT((var), field))
+
+#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = SLIST_FIRST((head));				\
+	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
+	for ((varp) = &SLIST_FIRST((head));				\
+	    ((var) = *(varp)) != NULL;					\
+	    (varp) = &SLIST_NEXT((var), field))
+
+#define	SLIST_INIT(head) do {						\
+	SLIST_FIRST((head)) = NULL;					\
+} while (*"\0")
+
+#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
+	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);	\
+	SLIST_NEXT((slistelm), field) = (elm);				\
+} while (*"\0")
+
+#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
+	SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
+	SLIST_FIRST((head)) = (elm);					\
+} while (*"\0")
+
+#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
+
+#define	SLIST_REMOVE(head, elm, type, field) do {			\
+	if (SLIST_FIRST((head)) == (elm)) {				\
+		SLIST_REMOVE_HEAD((head), field);			\
+	}								\
+	else {								\
+		struct type *curelm = SLIST_FIRST((head));		\
+		while (SLIST_NEXT(curelm, field) != (elm))		\
+			curelm = SLIST_NEXT(curelm, field);		\
+		SLIST_NEXT(curelm, field) =				\
+		    SLIST_NEXT(SLIST_NEXT(curelm, field), field);	\
+	}								\
+	TRASHIT((elm)->field.sle_next);					\
+} while (*"\0")
+
+#define	SLIST_REMOVE_HEAD(head, field) do {				\
+	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
+} while (*"\0")
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#define	STAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *stqh_first;/* first element */			\
+	struct type **stqh_last;/* addr of last next element */		\
+}
+
+#define	STAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).stqh_first }
+
+#define	STAILQ_ENTRY(type)						\
+struct {								\
+	struct type *stqe_next;	/* next element */			\
+}
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#define	STAILQ_CONCAT(head1, head2) do {				\
+	if (!STAILQ_EMPTY((head2))) {					\
+		*(head1)->stqh_last = (head2)->stqh_first;		\
+		(head1)->stqh_last = (head2)->stqh_last;		\
+		STAILQ_INIT((head2));					\
+	}								\
+} while (*"\0")
+
+#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
+
+#define	STAILQ_FIRST(head)	((head)->stqh_first)
+
+#define	STAILQ_FOREACH(var, head, field)				\
+	for((var) = STAILQ_FIRST((head));				\
+	   (var);							\
+	   (var) = STAILQ_NEXT((var), field))
+
+
+#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = STAILQ_FIRST((head));				\
+	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#define	STAILQ_INIT(head) do {						\
+	STAILQ_FIRST((head)) = NULL;					\
+	(head)->stqh_last = &STAILQ_FIRST((head));			\
+} while (*"\0")
+
+#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
+	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+	STAILQ_NEXT((tqelm), field) = (elm);				\
+} while (*"\0")
+
+#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
+	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+	STAILQ_FIRST((head)) = (elm);					\
+} while (*"\0")
+
+#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
+	STAILQ_NEXT((elm), field) = NULL;				\
+	*(head)->stqh_last = (elm);					\
+	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
+} while (*"\0")
+
+#define	STAILQ_LAST(head, type, field)					\
+	(STAILQ_EMPTY((head)) ?						\
+		NULL :							\
+	        ((struct type *)(void *)				\
+		((char *)((head)->stqh_last) - __offsetof(struct type, field))))
+
+#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
+
+#define	STAILQ_REMOVE(head, elm, type, field) do {			\
+	if (STAILQ_FIRST((head)) == (elm)) {				\
+		STAILQ_REMOVE_HEAD((head), field);			\
+	}								\
+	else {								\
+		struct type *curelm = STAILQ_FIRST((head));		\
+		while (STAILQ_NEXT(curelm, field) != (elm))		\
+			curelm = STAILQ_NEXT(curelm, field);		\
+		if ((STAILQ_NEXT(curelm, field) =			\
+		     STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
+			(head)->stqh_last = &STAILQ_NEXT((curelm), field);\
+	}								\
+	TRASHIT((elm)->field.stqe_next);				\
+} while (*"\0")
+
+#define	STAILQ_REMOVE_HEAD(head, field) do {				\
+	if ((STAILQ_FIRST((head)) =					\
+	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
+		(head)->stqh_last = &STAILQ_FIRST((head));		\
+} while (*"\0")
+
+#define	STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do {			\
+	if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL)	\
+		(head)->stqh_last = &STAILQ_FIRST((head));		\
+} while (*"\0")
+
+/*
+ * List declarations.
+ */
+#define	LIST_HEAD(name, type)						\
+struct name {								\
+	struct type *lh_first;	/* first element */			\
+}
+
+#define	LIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#define	LIST_ENTRY(type)						\
+struct {								\
+	struct type *le_next;	/* next element */			\
+	struct type **le_prev;	/* address of previous next element */	\
+}
+
+/*
+ * List functions.
+ */
+
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define	QMD_LIST_CHECK_HEAD(head, field) do {				\
+	if (LIST_FIRST((head)) != NULL &&				\
+	    LIST_FIRST((head))->field.le_prev !=			\
+	     &LIST_FIRST((head)))					\
+		panic("Bad list head %p first->prev != head", (head));	\
+} while (*"\0")
+
+#define	QMD_LIST_CHECK_NEXT(elm, field) do {				\
+	if (LIST_NEXT((elm), field) != NULL &&				\
+	    LIST_NEXT((elm), field)->field.le_prev !=			\
+	     &((elm)->field.le_next))					\
+	     	panic("Bad link elm %p next->prev != elm", (elm));	\
+} while (*"\0")
+
+#define	QMD_LIST_CHECK_PREV(elm, field) do {				\
+	if (*(elm)->field.le_prev != (elm))				\
+		panic("Bad link elm %p prev->next != elm", (elm));	\
+} while (*"\0")
+#else
+#define	QMD_LIST_CHECK_HEAD(head, field)
+#define	QMD_LIST_CHECK_NEXT(elm, field)
+#define	QMD_LIST_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define	LIST_EMPTY(head)	((head)->lh_first == NULL)
+
+#define	LIST_FIRST(head)	((head)->lh_first)
+
+#define	LIST_FOREACH(var, head, field)					\
+	for ((var) = LIST_FIRST((head));				\
+	    (var);							\
+	    (var) = LIST_NEXT((var), field))
+
+#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = LIST_FIRST((head));				\
+	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#define	LIST_INIT(head) do {						\
+	LIST_FIRST((head)) = NULL;					\
+} while (*"\0")
+
+#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
+	QMD_LIST_CHECK_NEXT(listelm, field);				\
+	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
+		LIST_NEXT((listelm), field)->field.le_prev =		\
+		    &LIST_NEXT((elm), field);				\
+	LIST_NEXT((listelm), field) = (elm);				\
+	(elm)->field.le_prev = &LIST_NEXT((listelm), field);		\
+} while (*"\0")
+
+#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
+	QMD_LIST_CHECK_PREV(listelm, field);				\
+	(elm)->field.le_prev = (listelm)->field.le_prev;		\
+	LIST_NEXT((elm), field) = (listelm);				\
+	*(listelm)->field.le_prev = (elm);				\
+	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
+} while (*"\0")
+
+#define	LIST_INSERT_HEAD(head, elm, field) do {				\
+	QMD_LIST_CHECK_HEAD((head), field);				\
+	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
+		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
+	LIST_FIRST((head)) = (elm);					\
+	(elm)->field.le_prev = &LIST_FIRST((head));			\
+} while (*"\0")
+
+#define	LIST_NEXT(elm, field)	((elm)->field.le_next)
+
+#define	LIST_REMOVE(elm, field) do {					\
+	QMD_LIST_CHECK_NEXT(elm, field);				\
+	QMD_LIST_CHECK_PREV(elm, field);				\
+	if (LIST_NEXT((elm), field) != NULL)				\
+		LIST_NEXT((elm), field)->field.le_prev = 		\
+		    (elm)->field.le_prev;				\
+	*(elm)->field.le_prev = LIST_NEXT((elm), field);		\
+	TRASHIT((elm)->field.le_next);					\
+	TRASHIT((elm)->field.le_prev);					\
+} while (*"\0")
+
+/*
+ * Tail queue declarations.
+ */
+#define	TAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *tqh_first;	/* first element */			\
+	struct type **tqh_last;	/* addr of last next element */		\
+	TRACEBUF							\
+}
+
+#define	TAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).tqh_first }
+
+#define	TAILQ_ENTRY(type)						\
+struct {								\
+	struct type *tqe_next;	/* next element */			\
+	struct type **tqe_prev;	/* address of previous next element */	\
+	TRACEBUF							\
+}
+
+/*
+ * Tail queue functions.
+ */
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
+	if (!TAILQ_EMPTY(head) &&					\
+	    TAILQ_FIRST((head))->field.tqe_prev !=			\
+	     &TAILQ_FIRST((head)))					\
+		panic("Bad tailq head %p first->prev != head", (head));	\
+} while (*"\0")
+
+#define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
+	if (*(head)->tqh_last != NULL)					\
+	    	panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
+} while (*"\0")
+
+#define	QMD_TAILQ_CHECK_NEXT(elm, field) do {				\
+	if (TAILQ_NEXT((elm), field) != NULL &&				\
+	    TAILQ_NEXT((elm), field)->field.tqe_prev !=			\
+	     &((elm)->field.tqe_next))					\
+		panic("Bad link elm %p next->prev != elm", (elm));	\
+} while (*"\0")
+
+#define	QMD_TAILQ_CHECK_PREV(elm, field) do {				\
+	if (*(elm)->field.tqe_prev != (elm))				\
+		panic("Bad link elm %p prev->next != elm", (elm));	\
+} while (*"\0")
+#else
+#define	QMD_TAILQ_CHECK_HEAD(head, field)
+#define	QMD_TAILQ_CHECK_TAIL(head, headname)
+#define	QMD_TAILQ_CHECK_NEXT(elm, field)
+#define	QMD_TAILQ_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define	TAILQ_CONCAT(head1, head2, field) do {				\
+	if (!TAILQ_EMPTY(head2)) {					\
+		*(head1)->tqh_last = (head2)->tqh_first;		\
+		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
+		(head1)->tqh_last = (head2)->tqh_last;			\
+		TAILQ_INIT((head2));					\
+		QMD_TRACE_HEAD(head1);					\
+		QMD_TRACE_HEAD(head2);					\
+	}								\
+} while (*"\0")
+
+#define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
+
+#define	TAILQ_FIRST(head)	((head)->tqh_first)
+
+#define	TAILQ_FOREACH(var, head, field)					\
+	for ((var) = TAILQ_FIRST((head));				\
+	    (var);							\
+	    (var) = TAILQ_NEXT((var), field))
+
+#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = TAILQ_FIRST((head));				\
+	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
+	    (var) = (tvar))
+
+#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
+	for ((var) = TAILQ_LAST((head), headname);			\
+	    (var);							\
+	    (var) = TAILQ_PREV((var), headname, field))
+
+#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
+	for ((var) = TAILQ_LAST((head), headname);			\
+	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
+	    (var) = (tvar))
+
+#define	TAILQ_INIT(head) do {						\
+	TAILQ_FIRST((head)) = NULL;					\
+	(head)->tqh_last = &TAILQ_FIRST((head));			\
+	QMD_TRACE_HEAD(head);						\
+} while (*"\0")
+
+#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	QMD_TAILQ_CHECK_NEXT(listelm, field);				\
+	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
+		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
+		    &TAILQ_NEXT((elm), field);				\
+	else {								\
+		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
+		QMD_TRACE_HEAD(head);					\
+	}								\
+	TAILQ_NEXT((listelm), field) = (elm);				\
+	(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);		\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+	QMD_TRACE_ELEM(&listelm->field);				\
+} while (*"\0")
+
+#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
+	QMD_TAILQ_CHECK_PREV(listelm, field);				\
+	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
+	TAILQ_NEXT((elm), field) = (listelm);				\
+	*(listelm)->field.tqe_prev = (elm);				\
+	(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);		\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+	QMD_TRACE_ELEM(&listelm->field);				\
+} while (*"\0")
+
+#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
+	QMD_TAILQ_CHECK_HEAD(head, field);				\
+	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
+		TAILQ_FIRST((head))->field.tqe_prev =			\
+		    &TAILQ_NEXT((elm), field);				\
+	else								\
+		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
+	TAILQ_FIRST((head)) = (elm);					\
+	(elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
+	QMD_TRACE_HEAD(head);						\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+} while (*"\0")
+
+#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
+	QMD_TAILQ_CHECK_TAIL(head, field);				\
+	TAILQ_NEXT((elm), field) = NULL;				\
+	(elm)->field.tqe_prev = (head)->tqh_last;			\
+	*(head)->tqh_last = (elm);					\
+	(head)->tqh_last = &TAILQ_NEXT((elm), field);			\
+	QMD_TRACE_HEAD(head);						\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+} while (*"\0")
+
+#define	TAILQ_LAST(head, headname)					\
+	(*(((struct headname *)((head)->tqh_last))->tqh_last))
+
+#define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#define	TAILQ_PREV(elm, headname, field)				\
+	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+#define	TAILQ_REMOVE(head, elm, field) do {				\
+	QMD_TAILQ_CHECK_NEXT(elm, field);				\
+	QMD_TAILQ_CHECK_PREV(elm, field);				\
+	if ((TAILQ_NEXT((elm), field)) != NULL)				\
+		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
+		    (elm)->field.tqe_prev;				\
+	else {								\
+		(head)->tqh_last = (elm)->field.tqe_prev;		\
+		QMD_TRACE_HEAD(head);					\
+	}								\
+	*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);		\
+	TRASHIT((elm)->field.tqe_next);					\
+	TRASHIT((elm)->field.tqe_prev);					\
+	QMD_TRACE_ELEM(&(elm)->field);					\
+} while (*"\0")
+
+
+#ifdef _KERNEL
+
+#endif /* _KERNEL */
+
+#endif /* !_SYS_QUEUE_H_ */
+
+/* END CSTYLED */
diff --git a/src/VBox/Additions/solaris/DRM/vboxvideo_drm.c b/src/VBox/Additions/solaris/DRM/vboxvideo_drm.c
new file mode 100644
index 00000000..4910d9f1
--- /dev/null
+++ b/src/VBox/Additions/solaris/DRM/vboxvideo_drm.c
@@ -0,0 +1,399 @@
+/* $Id: vboxvideo_drm.c $ */
+/** @file
+ * vboxvideo_drm - Direct Rendering Module, Solaris Specific Code.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#undef offsetof     /* This gets redefined in drmP.h */
+#include "include/drmP.h"
+#include "include/drm.h"
+
+#undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
+
+#include <VBox/log.h>
+#include <VBox/version.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define VBOXSOLQUOTE2(x)                #x
+#define VBOXSOLQUOTE(x)                 VBOXSOLQUOTE2(x)
+/** The module name. */
+#define DEVICE_NAME                     "vboxvideo"
+/** The module description as seen in 'modinfo'. */
+#define DEVICE_DESC_DRV                 "VirtualBox DRM"
+
+/** DRM Specific defines */
+#define DRIVER_AUTHOR                   "Oracle Corporation"
+#define DRIVER_NAME                     DEVICE_NAME
+#define DRIVER_DESC                     DEVICE_DESC_DRV
+#define DRIVER_DATE                     "20090317"
+#define DRIVER_MAJOR                    1
+#define DRIVER_MINOR                    0
+#define DRIVER_PATCHLEVEL               0
+#define vboxvideo_PCI_IDS               { 0x80ee, 0xbeef, 0, "VirtualBox Video" }, \
+                                        { 0, 0, 0, NULL }
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static int VBoxVideoSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd);
+static int VBoxVideoSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
+static int VBoxVideoSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppvResult);
+
+static void vboxVideoSolarisConfigure(drm_driver_t *pDriver);
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+extern struct cb_ops drm_cb_ops;
+
+/**
+ * dev_ops: for driver device operations
+ */
+static struct dev_ops g_VBoxVideoSolarisDevOps =
+{
+    DEVO_REV,               /* driver build revision */
+    0,                      /* ref count */
+    VBoxVideoSolarisGetInfo,
+    nulldev,                /* identify */
+    nulldev,                /* probe */
+    VBoxVideoSolarisAttach,
+    VBoxVideoSolarisDetach,
+    nodev,                  /* reset */
+    &drm_cb_ops,
+    NULL,                   /* dev bus ops*/
+    NULL                    /* power */
+};
+
+/**
+ * modldrv: export driver specifics to the kernel
+ */
+static struct modldrv g_VBoxVideoSolarisModule =
+{
+    &mod_driverops,         /* extern from kernel */
+    DEVICE_DESC_DRV " " VBOX_VERSION_STRING "r" VBOXSOLQUOTE(VBOX_SVN_REV),
+    &g_VBoxVideoSolarisDevOps
+};
+
+/**
+ * modlinkage: export install/remove/info to the kernel
+ */
+static struct modlinkage g_VBoxVideoSolarisModLinkage =
+{
+    MODREV_1,               /* loadable module system revision */
+    &g_VBoxVideoSolarisModule,
+    NULL                    /* terminate array of linkage structures */
+};
+
+/* VBoxVideo device PCI ID */
+static drm_pci_id_list_t vboxvideo_pciidlist[] = {
+    vboxvideo_PCI_IDS
+};
+
+
+/** DRM Driver */
+static drm_driver_t	g_VBoxVideoSolarisDRMDriver = { 0 };
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Soft state. */
+static void *g_pVBoxVideoSolarisState;
+
+
+/**
+ * Kernel entry points
+ */
+int _init(void)
+{
+    LogFlow((DEVICE_NAME ":_init flow\n"));
+    cmn_err(CE_NOTE, DEVICE_NAME ":_init\n");
+
+    vboxVideoSolarisConfigure(&g_VBoxVideoSolarisDRMDriver);
+    int rc = ddi_soft_state_init(&g_pVBoxVideoSolarisState, sizeof(drm_device_t), DRM_MAX_INSTANCES);
+    if (!rc)
+        return mod_install(&g_VBoxVideoSolarisModLinkage);
+    else
+        LogRel((DEVICE_NAME ":_init: ddi_soft_state_init failed. rc=%d\n", rc));
+}
+
+
+int _fini(void)
+{
+    LogFlow((DEVICE_NAME ":_fini flow\n"));
+    cmn_err(CE_NOTE, DEVICE_NAME ":_fini\n");
+    int rc = mod_remove(&g_VBoxVideoSolarisModLinkage);
+    if (!rc)
+        ddi_soft_state_fini(&g_pVBoxVideoSolarisState);
+    return rc;
+}
+
+
+int _info(struct modinfo *pModInfo)
+{
+    LogFlow((DEVICE_NAME ":_info flow\n"));
+    cmn_err(CE_NOTE, DEVICE_NAME ":_info\n");
+    return mod_info(&g_VBoxVideoSolarisModLinkage, pModInfo);
+}
+
+
+/**
+ * Attach entry point, to attach a device to the system or resume it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   enmCmd          Operation type (attach/resume).
+ *
+ * @returns corresponding solaris error code.
+ */
+static int VBoxVideoSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
+{
+    LogFlow((DEVICE_NAME ":VBoxVideoSolarisAttach pDip=%p enmCmd=%d\n", pDip, enmCmd));
+    cmn_err(CE_NOTE, DEVICE_NAME ":attach\n");
+
+    switch (enmCmd)
+    {
+        case DDI_ATTACH:
+        {
+            drm_device_t *pState;
+            int Instance = ddi_get_instance(pDip);
+            int rc = ddi_soft_state_zalloc(g_pVBoxVideoSolarisState, Instance);
+            if (rc == DDI_SUCCESS)
+            {
+                pState = ddi_get_soft_state(g_pVBoxVideoSolarisState, Instance);
+                pState->dip = pDip;
+                pState->driver = &g_VBoxVideoSolarisDRMDriver;
+
+                /*
+                 * Register using the DRM module which will create the minor nodes
+                 */
+                void *pDRMHandle = drm_supp_register(pDip, pState);
+                if (pDRMHandle)
+                {
+                    pState->drm_handle = pDRMHandle;
+
+                    /*
+                     * Probe with our pci-id.
+                     * -XXX- is probing really required???
+                     */
+                    pState->drm_supported = DRM_UNSUPPORT;
+                    rc = drm_probe(pState, vboxvideo_pciidlist);
+                    if (rc == DDI_SUCCESS)
+                    {
+                        pState->drm_supported = DRM_SUPPORT;
+
+                        /*
+                         * Call the common attach DRM routine.
+                         */
+                        rc = drm_attach(pState);
+                        if (rc == DDI_SUCCESS)
+                        {
+                            return DDI_SUCCESS;
+                        }
+                        else
+                            LogRel((DEVICE_NAME ":VBoxVideoSolarisAttach drm_attach failed.rc=%d\n", rc));
+                    }
+                    else
+                        LogRel((DEVICE_NAME ":VBoxVideoSolarisAttach drm_probe failed.rc=%d\n", rc));
+
+                    drm_supp_unregister(pDRMHandle);
+                }
+                else
+                    LogRel((DEVICE_NAME ":VBoxVideoSolarisAttach drm_supp_register failed.\n"));
+
+                ddi_soft_state_free(g_pVBoxVideoSolarisState, Instance);
+            }
+            else
+                LogRel((DEVICE_NAME ":VBoxVideoSolarisAttach failed to alloc memory for soft state.rc=%d\n", rc));
+            return DDI_FAILURE;
+        }
+
+        case DDI_RESUME:
+        {
+            /* Nothing to do here... */
+            return DDI_SUCCESS;
+        }
+    }
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Detach entry point, to detach a device to the system or suspend it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   enmCmd          Operation type (detach/suspend).
+ *
+ * @returns corresponding solaris error code.
+ */
+static int VBoxVideoSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
+{
+    LogFlow((DEVICE_NAME ":VBoxVideoSolarisDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
+
+    switch (enmCmd)
+    {
+        case DDI_DETACH:
+        {
+            int Instance = ddi_get_instance(pDip);
+            drm_device_t *pState = ddi_get_soft_state(g_pVBoxVideoSolarisState, Instance);
+            if (pState)
+            {
+                drm_detach(pState);
+                drm_supp_unregister(pState->drm_handle);
+                ddi_soft_state_free(g_pVBoxVideoSolarisState, Instance);
+                return DDI_SUCCESS;
+            }
+            else
+                LogRel((DEVICE_NAME ":VBoxVideoSolarisDetach failed to get soft state.\n"));
+
+            return DDI_FAILURE;
+        }
+
+        case DDI_RESUME:
+        {
+            /* Nothing to do here... */
+            return DDI_SUCCESS;
+        }
+    }
+    return DDI_FAILURE;
+}
+
+
+/*
+ * Info entry point, called by solaris kernel for obtaining driver info.
+ *
+ * @param   pDip            The module structure instance (do not use).
+ * @param   enmCmd          Information request type.
+ * @param   pvArg           Type specific argument.
+ * @param   ppvResult       Where to store the requested info.
+ *
+ * @return  corresponding solaris error code.
+ */
+static int VBoxVideoSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppvResult)
+{
+    LogFlow((DEVICE_NAME ":VBoxGuestSolarisGetInfo\n"));
+
+    int rc = DDI_FAILURE;
+    int Instance = drm_dev_to_instance((dev_t)pvArg);
+    drm_device_t *pState = NULL;
+    switch (enmCmd)
+    {
+        case DDI_INFO_DEVT2DEVINFO:
+        {
+            pState = ddi_get_soft_state(g_pVBoxVideoSolarisState, Instance);
+            if (   pState
+                && pState->dip)
+            {
+                *ppvResult = (void *)pState->dip;
+                rc = DDI_SUCCESS;
+            }
+            else
+            {
+                LogRel((DEVICE_NAME ":VBoxGuestSolarisGetInfo state or state's devinfo invalid.\n"));
+                rc = DDI_FAILURE;
+            }
+            break;
+        }
+
+        case DDI_INFO_DEVT2INSTANCE:
+        {
+            *ppvResult = (void *)(uintptr_t)Instance;
+            rc = DDI_SUCCESS;
+            break;
+        }
+
+        default:
+        {
+            rc = DDI_FAILURE;
+            break;
+        }
+    }
+
+    return rc;
+}
+
+
+static int vboxVideoSolarisLoad(drm_device_t *pDevice, unsigned long fFlag)
+{
+    return 0;
+}
+
+static int vboxVideoSolarisUnload(drm_device_t *pDevice)
+{
+    return 0;
+}
+
+static void vboxVideoSolarisLastClose(drm_device_t *pDevice)
+{
+}
+
+static void vboxVideoSolarisPreClose(drm_device_t *pDevice, drm_file_t *pFile)
+{
+}
+
+
+static void vboxVideoSolarisConfigure(drm_driver_t *pDriver)
+{
+    /*
+     * DRM entry points, use the common DRM extension wherever possible.
+     */
+    pDriver->buf_priv_size      = 1;
+    pDriver->load               = vboxVideoSolarisLoad;
+    pDriver->unload             = vboxVideoSolarisUnload;
+    pDriver->preclose           = vboxVideoSolarisPreClose;
+    pDriver->lastclose          = vboxVideoSolarisLastClose;
+    pDriver->device_is_agp      = drm_device_is_agp;
+#if 0
+    pDriver->get_vblank_counter = drm_vblank_count;
+    pDriver->enable_vblank      = NULL;
+    pDriver->disable_vblank     = NULL;
+    pDriver->irq_install        = drm_driver_irq_install;
+    pDriver->irq_preinstall     = drm_driver_irq_preinstall;
+    pDriver->irq_postinstall    = drm_driver_irq_postinstall;
+    pDirver->irq_uninstall      = drm_driver_irq_uninstall;
+    pDriver->irq_handler        = drm_driver_irq_handler;
+
+    pDriver->driver_ioctls      =
+    pDriver->max_driver_ioctls  =
+#endif
+
+    pDriver->driver_name        = DRIVER_NAME;
+    pDriver->driver_desc        = DRIVER_DESC;
+    pDriver->driver_date        = DRIVER_DATE;
+    pDriver->driver_major       = DRIVER_MAJOR;
+    pDriver->driver_minor       = DRIVER_MINOR;
+    pDriver->driver_patchlevel  = DRIVER_PATCHLEVEL;
+
+    pDriver->use_agp            = 1;
+    pDriver->require_agp        = 1;
+    pDriver->use_irq            = 1;
+}
+
diff --git a/src/VBox/Additions/solaris/Installer/VBox.sh b/src/VBox/Additions/solaris/Installer/VBox.sh
new file mode 100755
index 00000000..7ddebe05
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/VBox.sh
@@ -0,0 +1,51 @@
+#!/bin/sh
+# $Id: VBox.sh $
+## @file
+# VirtualBox startup script for Solaris Guests Additions
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+CURRENT_ISA=`isainfo -k`
+if test "$CURRENT_ISA" = "amd64"; then
+    INSTALL_DIR="/opt/VirtualBoxAdditions/amd64"
+else
+    INSTALL_DIR="/opt/VirtualBoxAdditions"
+fi
+
+APP=`basename $0`
+case "$APP" in
+    VBoxClient)
+        exec "$INSTALL_DIR/VBoxClient" "$@"
+        ;;
+    VBoxService)
+        exec "$INSTALL_DIR/VBoxService" "$@"
+        ;;
+    VBoxControl)
+        exec "$INSTALL_DIR/VBoxControl" "$@"
+        ;;
+    *)
+        echo "Unknown application - $APP"
+        exit 1
+        ;;
+esac
+exit 0
diff --git a/src/VBox/Additions/solaris/Installer/makepackage.sh b/src/VBox/Additions/solaris/Installer/makepackage.sh
new file mode 100755
index 00000000..0092b8c3
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/makepackage.sh
@@ -0,0 +1,150 @@
+#!/bin/sh
+# $Id: makepackage.sh $
+## @file
+# VirtualBox Solaris Guest Additions package creation script.
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+#
+# Usage:
+#       makespackage.sh $(PATH_TARGET)/install packagename svnrev
+
+if test -z "$3"; then
+    echo "Usage: $0 installdir packagename svnrev"
+    exit 1
+fi
+ostype=`uname -s`
+if test "$ostype" != "Linux" && test "$ostype" != "SunOS" ; then
+  echo "Linux/Solaris not detected."
+  exit 1
+fi
+
+VBOX_BASEPKG_DIR=$1
+VBOX_INSTALLED_DIR="$VBOX_BASEPKG_DIR"/opt/VirtualBoxAdditions
+VBOX_PKGFILENAME=$2
+VBOX_SVN_REV=$3
+
+VBOX_PKGNAME=SUNWvboxguest
+VBOX_AWK=/usr/bin/awk
+case "$ostype" in
+"SunOS")
+  VBOX_GGREP=/usr/sfw/bin/ggrep
+  VBOX_SOL_PKG_DEV=/var/spool/pkg
+  ;;
+*)
+  VBOX_GGREP=`which grep`
+  VBOX_SOL_PKG_DEV=$4
+  ;;
+esac
+VBOX_AWK=/usr/bin/awk
+
+# check for GNU grep we use which might not ship with all Solaris
+if test ! -f "$VBOX_GGREP" && test ! -h "$VBOX_GGREP"; then
+    echo "## GNU grep not found in $VBOX_GGREP."
+    exit 1
+fi
+
+# bail out on non-zero exit status
+set -e
+
+# Fixup filelist using awk, the parameters must be in awk syntax
+# params: filename condition action
+filelist_fixup()
+{
+    "$VBOX_AWK" 'NF == 6 && '"$2"' { '"$3"' } { print }' "$1" > "tmp-$1"
+    mv -f "tmp-$1" "$1"
+}
+
+dirlist_fixup()
+{
+  "$VBOX_AWK" 'NF == 6 && $1 == "d" && '"$2"' { '"$3"' } { print }' "$1" > "tmp-$1"
+  mv -f "tmp-$1" "$1"
+}
+
+# Create relative hardlinks
+cd "$VBOX_INSTALLED_DIR"
+ln -f ./VBoxISAExec $VBOX_INSTALLED_DIR/VBoxService
+ln -f ./VBoxISAExec $VBOX_INSTALLED_DIR/VBoxClient
+ln -f ./VBoxISAExec $VBOX_INSTALLED_DIR/VBoxControl
+ln -f ./VBoxISAExec $VBOX_INSTALLED_DIR/vboxmslnk
+
+# prepare file list
+cd "$VBOX_BASEPKG_DIR"
+echo 'i pkginfo=./vboxguest.pkginfo' > prototype
+echo 'i postinstall=./postinstall.sh' >> prototype
+echo 'i preremove=./preremove.sh' >> prototype
+echo 'i space=./vboxguest.space' >> prototype
+echo 'i depend=./vboxguest.depend' >> prototype
+if test -f "./vboxguest.copyright"; then
+    echo 'i copyright=./vboxguest.copyright' >> prototype
+fi
+
+# Exclude directory entries to not cause conflicts (owner,group) with existing directories in the system
+find . ! -type d | $VBOX_GGREP -v -E 'prototype|makepackage.sh|vboxguest.pkginfo|postinstall.sh|preremove.sh|vboxguest.space|vboxguest.depend|vboxguest.copyright' | pkgproto >> prototype
+
+# Include opt/VirtualBoxAdditions and subdirectories as we want uninstall to clean up directory structure as well
+find . -type d | $VBOX_GGREP -E 'opt/VirtualBoxAdditions|var/svc/manifest/application/virtualbox' | pkgproto >> prototype
+
+# Include /etc/fs/vboxfs (as we need to create the subdirectory)
+find . -type d | $VBOX_GGREP -E 'etc/fs/vboxfs' | pkgproto >> prototype
+
+
+# don't grok for the class files
+filelist_fixup prototype '$2 == "none"'                                                                      '$5 = "root"; $6 = "bin"'
+
+# VBoxService requires suid
+filelist_fixup prototype '$3 == "opt/VirtualBoxAdditions/VBoxService"'                                       '$4 = "4755"'
+filelist_fixup prototype '$3 == "opt/VirtualBoxAdditions/amd64/VBoxService"'                                 '$4 = "4755"'
+
+# Manifest class action scripts
+filelist_fixup prototype '$3 == "var/svc/manifest/application/virtualbox/vboxservice.xml"'                   '$2 = "manifest";$6 = "sys"'
+filelist_fixup prototype '$3 == "var/svc/manifest/application/virtualbox/vboxmslnk.xml"'                     '$2 = "manifest";$6 = "sys"'
+
+# vboxguest
+filelist_fixup prototype '$3 == "usr/kernel/drv/vboxguest"'                                                  '$6="sys"'
+filelist_fixup prototype '$3 == "usr/kernel/drv/amd64/vboxguest"'                                            '$6="sys"'
+
+# vboxms
+filelist_fixup prototype '$3 == "usr/kernel/drv/vboxms"'                                                     '$6="sys"'
+filelist_fixup prototype '$3 == "usr/kernel/drv/amd64/vboxms"'                                               '$6="sys"'
+
+# Use 'root' as group so as to match attributes with the previous installation and prevent a conflict. Otherwise pkgadd bails out thinking
+# we're violating directory attributes of another (non existing) package
+dirlist_fixup prototype  '$3 == "var/svc/manifest/application/virtualbox"'                                   '$6 = "root"'
+
+echo " --- start of prototype  ---"
+cat prototype
+echo " --- end of prototype --- "
+
+# explicitly set timestamp to shutup warning
+VBOXPKG_TIMESTAMP=vboxguest`date '+%Y%m%d%H%M%S'`_r$VBOX_SVN_REV
+
+# create the package instance
+pkgmk -d $VBOX_SOL_PKG_DEV -p $VBOXPKG_TIMESTAMP -o -r .
+
+# translate into package datastream
+pkgtrans -s -o "$VBOX_SOL_PKG_DEV" `pwd`/$VBOX_PKGFILENAME "$VBOX_PKGNAME"
+
+rm -rf "$VBOX_SOL_PKG_DEV/$VBOX_PKGNAME"
+exit $?
+
diff --git a/src/VBox/Additions/solaris/Installer/postinstall.sh b/src/VBox/Additions/solaris/Installer/postinstall.sh
new file mode 100755
index 00000000..9e49df38
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/postinstall.sh
@@ -0,0 +1,399 @@
+#!/bin/sh
+# $Id: postinstall.sh $
+## @file
+# VirtualBox postinstall script for Solaris Guest Additions.
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+# LC_ALL should take precedence over LC_* and LANG but whatever...
+LC_ALL=C
+export LC_ALL
+
+LANG=C
+export LANG
+
+# uncompress(directory, file)
+# Updates package metadata and uncompresses the file.
+uncompress_file()
+{
+    if test -z "$1" || test -z "$2"; then
+        echo "missing argument to uncompress_file()"
+        return 1
+    fi
+
+    # Remove compressed path from the pkg
+    /usr/sbin/removef $PKGINST "$1/$2.Z" 1>/dev/null
+
+    # Add uncompressed path to the pkg
+    /usr/sbin/installf -c none $PKGINST "$1/$2" f
+
+    # Uncompress the file (removes compressed file when done)
+    uncompress -f "$1/$2.Z" > /dev/null 2>&1
+}
+
+# uncompress_files(directory_with_*.Z_files)
+uncompress_files()
+{
+    for i in "${1}/"*.Z; do
+        uncompress_file "${1}" "`basename \"${i}\" .Z`"
+    done
+}
+
+solaris64dir="amd64"
+solaris32dir="i386"
+vboxadditions_path="$BASEDIR/opt/VirtualBoxAdditions"
+vboxadditions32_path=$vboxadditions_path/$solaris32dir
+vboxadditions64_path=$vboxadditions_path/$solaris64dir
+
+# get the current zone
+currentzone=`zonename`
+# get what ISA the guest is running
+cputype=`isainfo -k`
+if test "$cputype" = "amd64"; then
+    isadir=$solaris64dir
+else
+    isadir=""
+fi
+
+vboxadditionsisa_path=$vboxadditions_path/$isadir
+
+
+# uncompress if necessary
+if test -f "$vboxadditions32_path/VBoxClient.Z" || test -f "$vboxadditions64_path/VBoxClient.Z"; then
+    echo "Uncompressing files..."
+    if test -f "$vboxadditions32_path/VBoxClient.Z"; then
+        uncompress_files "$vboxadditions32_path"
+    fi
+    if test -f "$vboxadditions64_path/VBoxClient.Z"; then
+        uncompress_files "$vboxadditions64_path"
+    fi
+fi
+
+
+if test "$currentzone" = "global"; then
+    # vboxguest.sh would've been installed, we just need to call it.
+    echo "Configuring VirtualBox guest kernel module..."
+    # stop all previous modules (vboxguest, vboxfs) and start only starts vboxguest
+    $vboxadditions_path/vboxguest.sh stopall silentunload
+    $vboxadditions_path/vboxguest.sh start
+
+    sed -e '/name=vboxguest/d' /etc/devlink.tab > /etc/devlink.vbox
+    echo "type=ddi_pseudo;name=vboxguest	\D" >> /etc/devlink.vbox
+    mv -f /etc/devlink.vbox /etc/devlink.tab
+
+    # create the device link
+    /usr/sbin/devfsadm -i vboxguest
+fi
+
+
+# check if X.Org exists (snv_130 and higher have /usr/X11/* as /usr/*)
+if test -f "/usr/bin/Xorg"; then
+    xorgbin="/usr/bin/Xorg"
+elif test -f "/usr/X11/bin/Xorg"; then
+    xorgbin="/usr/X11/bin/Xorg"
+else
+    xorgbin=""
+    retval=0
+fi
+
+# create links
+echo "Creating links..."
+if test "$currentzone" = "global"; then
+    /usr/sbin/installf -c none $PKGINST /dev/vboxguest=../devices/pci@0,0/pci80ee,cafe@4:vboxguest s
+    /usr/sbin/installf -c none $PKGINST /dev/vboxms=../devices/pseudo/vboxms@0:vboxms s
+fi
+
+# Install Xorg components to the required places
+if test ! -z "$xorgbin"; then
+    xorgversion_long=`$xorgbin -version 2>&1 | grep "X Window System Version"`
+    xorgversion=`/usr/bin/expr "${xorgversion_long}" : 'X Window System Version \([^ ]*\)'`
+    if test -z "$xorgversion_long"; then
+        xorgversion_long=`$xorgbin -version 2>&1 | grep "X.Org X Server"`
+        xorgversion=`/usr/bin/expr "${xorgversion_long}" : 'X.Org X Server \([^ ]*\)'`
+    fi
+
+    # "X.Y.Z" - strip off all numerics after the 2nd '.' character, e.g. "1.11.3" -> "1.11"
+    # Then the next sed, strips of all '.' characters, "1.11" -> "111".
+    fileversion=`echo $xorgversion | sed "s/\.[0-9]*//2" | sed "s/\.//"`
+    vboxvideo_src="vboxvideo_drv_$fileversion.so"
+
+    # Handle exceptions now where the X.org version does not exactly match the file-version.
+    case "$xorgversion" in
+        1.5.99 )
+            vboxvideo_src="vboxvideo_drv_16.so"
+            ;;
+        7.2.* )
+            vboxvideo_src="vboxvideo_drv_71.so"
+            ;;
+        6.9.* )
+            vboxvideo_src="vboxvideo_drv_70.so"
+            ;;
+    esac
+
+    retval=0
+    if test -z "$vboxvideo_src"; then
+        echo "*** Unknown version of the X Window System installed."
+        echo "*** Failed to install the VirtualBox X Window System drivers."
+
+        # Exit as partially failed installation
+        retval=2
+    elif test ! -f "$vboxadditions32_path/$vboxvideo_src" && test ! -f "$vboxadditions64_path/$vboxvideo_src"; then
+        # Xorg 1.19 and later already contain a driver for vboxvideo.
+        echo "As of X.Org Server 1.19, the VirtualBox graphics driver (vboxvideo) is part"
+        echo "of Solaris.  Please install it from the package repository if necessary."
+    else
+        echo "Installing video driver for X.Org $xorgversion..."
+
+        # Determine destination paths (snv_130 and above use "/usr/lib/xorg", older use "/usr/X11/lib"
+        vboxvideo32_dest_base="/usr/lib/xorg/modules/drivers"
+        if test ! -d $vboxvideo32_dest_base; then
+            vboxvideo32_dest_base="/usr/X11/lib/modules/drivers"
+        fi
+
+        vboxvideo64_dest_base=$vboxvideo32_dest_base/$solaris64dir
+
+        # snv_163 drops 32-bit support completely, and uses 32-bit locations for the 64-bit stuff. Ugly.
+        # We try to detect this by looking at bitness of "vesa_drv.so", and adjust our destination paths accordingly.
+        # We do not rely on using Xorg -version's ABI output because some builds (snv_162 iirc) have 64-bit ABI with
+        # 32-bit file locations.
+        if test -f "$vboxvideo32_dest_base/vesa_drv.so"; then
+            bitsize=`file "$vboxvideo32_dest_base/vesa_drv.so" | grep -i "32-bit"`
+            skip32="no"
+        else
+            echo "* Warning vesa_drv.so missing. Assuming Xorg ABI is 64-bit..."
+        fi
+
+        if test -z "$bitsize"; then
+            skip32="yes"
+            vboxvideo64_dest_base=$vboxvideo32_dest_base
+        fi
+
+        # Make sure destination path exists
+        if test ! -d $vboxvideo64_dest_base; then
+            echo "*** Missing destination paths for video module. Aborting."
+            echo "*** Failed to install the VirtualBox X Window System driver."
+
+            # Exit as partially failed installation
+            retval=2
+        else
+            # 32-bit x11 drivers
+            if test "$skip32" = "no" && test -f "$vboxadditions32_path/$vboxvideo_src"; then
+                vboxvideo_dest="$vboxvideo32_dest_base/vboxvideo_drv.so"
+                /usr/sbin/installf -c none $PKGINST "$vboxvideo_dest" f
+                cp "$vboxadditions32_path/$vboxvideo_src" "$vboxvideo_dest"
+
+                # Removing redundant names from pkg and files from disk
+                /usr/sbin/removef $PKGINST $vboxadditions32_path/vboxvideo_drv_* 1>/dev/null
+                rm -f $vboxadditions32_path/vboxvideo_drv_*
+            fi
+
+            # 64-bit x11 drivers
+            if test -f "$vboxadditions64_path/$vboxvideo_src"; then
+                vboxvideo_dest="$vboxvideo64_dest_base/vboxvideo_drv.so"
+                /usr/sbin/installf -c none $PKGINST "$vboxvideo_dest" f
+                cp "$vboxadditions64_path/$vboxvideo_src" "$vboxvideo_dest"
+
+                # Removing redundant names from pkg and files from disk
+                /usr/sbin/removef $PKGINST $vboxadditions64_path/vboxvideo_drv_* 1>/dev/null
+                rm -f $vboxadditions64_path/vboxvideo_drv_*
+            fi
+
+            # Some distros like Indiana have no xorg.conf, deal with this
+            if test ! -f '/etc/X11/xorg.conf' && test ! -f '/etc/X11/.xorg.conf'; then
+
+                # Xorg 1.3.x+ should use the modeline less Xorg confs while older should
+                # use ones with all the video modelines in place. Argh.
+                xorgconf_file="solaris_xorg_modeless.conf"
+                xorgconf_unfit="solaris_xorg.conf"
+                case "$xorgversion" in
+                    7.1.* | 7.2.* | 6.9.* | 7.0.* )
+                        xorgconf_file="solaris_xorg.conf"
+                        xorgconf_unfit="solaris_xorg_modeless.conf"
+                        ;;
+                esac
+
+                /usr/sbin/removef $PKGINST $vboxadditions_path/$xorgconf_file 1>/dev/null
+                mv -f $vboxadditions_path/$xorgconf_file /etc/X11/.xorg.conf
+
+                /usr/sbin/removef $PKGINST $vboxadditions_path/$xorgconf_unfit 1>/dev/null
+                rm -f $vboxadditions_path/$xorgconf_unfit
+            fi
+
+            # Check for VirtualBox graphics card
+            # S10u10's prtconf doesn't support the '-d' option, so let's use -v even though it's slower.
+            is_vboxgraphics=`prtconf -v | grep -i pci80ee,beef`
+            if test "$?" -eq 0; then
+                drivername="vboxvideo"
+            else
+                # Check for VMware graphics card
+                is_vmwaregraphics=`prtconf -v | grep -i pci15ad,405`
+                if test "$?" -eq 0; then
+                    echo "Configuring X.Org to use VMware SVGA graphics driver..."
+                    drivername="vmware"
+                fi
+            fi
+
+            # Adjust xorg.conf with video driver sections if a supported graphics card is found
+            if test ! -z "$drivername"; then
+                $vboxadditions_path/x11config15sol.pl "$drivername"
+            else
+                # No supported graphics card found, do nothing.
+                echo "## No supported graphics card found. Skipped configuring of X.org drivers."
+            fi
+        fi
+    fi
+
+
+    # Setup our VBoxClient
+    echo "Configuring client..."
+    vboxclient_src=$vboxadditions_path
+    vboxclient_dest="/usr/share/gnome/autostart"
+    clientinstalled=0
+    if test -d "$vboxclient_dest"; then
+        /usr/sbin/installf -c none $PKGINST $vboxclient_dest/vboxclient.desktop=$vboxadditions_path/vboxclient.desktop s
+        clientinstalled=1
+    fi
+    vboxclient_dest="/usr/dt/config/Xsession.d"
+    if test -d "$vboxclient_dest"; then
+        /usr/sbin/installf -c none $PKGINST $vboxclient_dest/1099.vboxclient=$vboxadditions_path/1099.vboxclient s
+        clientinstalled=1
+    fi
+
+    # Try other autostart locations if none of the above ones work
+    if test $clientinstalled -eq 0; then
+        vboxclient_dest="/etc/xdg/autostart"
+        if test -d "$vboxclient_dest"; then
+            /usr/sbin/installf -c none $PKGINST $vboxclient_dest/1099.vboxclient=$vboxadditions_path/1099.vboxclient s
+            clientinstalled=1
+        else
+            echo "*** Failed to configure client, couldn't find any autostart directory!"
+            # Exit as partially failed installation
+            retval=2
+        fi
+    fi
+else
+    echo "(*) X.Org not found, skipped configuring X.Org guest additions."
+fi
+
+
+# Shared Folder kernel module (different for S10 & Nevada)
+osverstr=`uname -r`
+vboxfsmod="vboxfs"
+vboxfsunused="vboxfs_s10"
+if test "$osverstr" = "5.10"; then
+    vboxfsmod="vboxfs_s10"
+    vboxfsunused="vboxfs"
+fi
+
+# Move the appropriate module to kernel/fs & remove the unused module name from pkg and file from disk
+# 64-bit shared folder module
+if test -f "$vboxadditions64_path/$vboxfsmod"; then
+    echo "Installing 64-bit shared folders module..."
+    /usr/sbin/installf -c none $PKGINST "/usr/kernel/fs/$solaris64dir/vboxfs" f
+    mv -f $vboxadditions64_path/$vboxfsmod /usr/kernel/fs/$solaris64dir/vboxfs
+    /usr/sbin/removef $PKGINST $vboxadditions64_path/$vboxfsmod 1>/dev/null
+    /usr/sbin/removef $PKGINST $vboxadditions64_path/$vboxfsunused 1>/dev/null
+    rm -f $vboxadditions64_path/$vboxfsunused
+fi
+
+# 32-bit shared folder module
+if test -f "$vboxadditions32_path/$vboxfsmod"; then
+    echo "Installing 32-bit shared folders module..."
+    /usr/sbin/installf -c none $PKGINST "/usr/kernel/fs/vboxfs" f
+    mv -f $vboxadditions32_path/$vboxfsmod /usr/kernel/fs/vboxfs
+    /usr/sbin/removef $PKGINST $vboxadditions32_path/$vboxfsmod 1>/dev/null
+    /usr/sbin/removef $PKGINST $vboxadditions32_path/$vboxfsunused 1>/dev/null
+    rm -f $vboxadditions32_path/$vboxfsunused
+fi
+
+# Add a group "vboxsf" for Shared Folders access
+# All users which want to access the auto-mounted Shared Folders have to
+# be added to this group.
+groupadd vboxsf >/dev/null 2>&1
+
+# Move the pointer integration module to kernel/drv & remove the unused module name from pkg and file from disk
+
+# Finalize
+/usr/sbin/removef -f $PKGINST
+/usr/sbin/installf -f $PKGINST
+
+
+if test "$currentzone" = "global"; then
+    /usr/sbin/devfsadm -i vboxguest
+
+    # Setup VBoxService and vboxmslnk and start the services automatically
+    echo "Configuring services (this might take a while)..."
+    cmax=32
+    cslept=0
+    success=0
+    sync
+
+    # Since S11 the way to import a manifest is via restarting manifest-import which is asynchronous and can
+    # take a while to complete, using disable/enable -s doesn't work either. So we restart it, and poll in
+    # 1 second intervals to see if our service has been successfully imported and timeout after 'cmax' seconds.
+    /usr/sbin/svcadm restart svc:system/manifest-import:default
+    /usr/bin/svcs virtualbox/vboxservice virtualbox/vboxmslnk >/dev/null 2>&1
+    while test "$?" -ne 0;
+    do
+        sleep 1
+        cslept=`expr $cslept + 1`
+        if test "$cslept" -eq "$cmax"; then
+            success=1
+            break
+        fi
+        /usr/bin/svcs virtualbox/vboxservice virtualbox/vboxmslnk >/dev/null 2>&1
+    done
+    if test "$success" -eq 0; then
+        echo "Enabling services..."
+        /usr/sbin/svcadm enable -s virtualbox/vboxservice
+        /usr/sbin/svcadm enable -s virtualbox/vboxmslnk
+    else
+        echo "## Service import failed."
+        echo "## See /var/svc/log/system-manifest-import:default.log for details."
+        # Exit as partially failed installation
+        retval=2
+    fi
+
+    # Update boot archive
+    BOOTADMBIN=/sbin/bootadm
+    if test -x "$BOOTADMBIN"; then
+        if test -h "/dev/vboxguest"; then
+            echo "Updating boot archive..."
+            $BOOTADMBIN update-archive > /dev/null
+        else
+            echo "## Guest kernel module doesn't seem to be up. Skipped explicit boot-archive update."
+        fi
+    else
+        echo "## $BOOTADMBIN not found/executable. Skipped explicit boot-archive update."
+    fi
+fi
+
+echo "Done."
+if test $retval -eq 0; then
+    if test ! -z "$xorgbin"; then
+        echo "Please re-login to activate the X11 guest additions."
+    fi
+    echo "If you have just un-installed the previous guest additions a REBOOT is required."
+fi
+exit $retval
+
diff --git a/src/VBox/Additions/solaris/Installer/preremove.sh b/src/VBox/Additions/solaris/Installer/preremove.sh
new file mode 100755
index 00000000..2cdd137e
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/preremove.sh
@@ -0,0 +1,69 @@
+#!/bin/sh
+# $Id: preremove.sh $
+## @file
+# VirtualBox preremove script for Solaris Guest Additions.
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+LC_ALL=C
+export LC_ALL
+
+LANG=C
+export LANG
+
+echo "Removing VirtualBox service..."
+
+# stop and unregister VBoxService
+/usr/sbin/svcadm disable -s virtualbox/vboxservice
+# Don't need to delete, taken care of by the manifest action
+# /usr/sbin/svccfg delete svc:/application/virtualbox/vboxservice:default
+/usr/sbin/svcadm restart svc:/system/manifest-import:default
+
+# stop VBoxClient
+pkill -INT VBoxClient
+
+echo "Removing VirtualBox kernel modules..."
+
+# vboxguest.sh would've been installed, we just need to call it.
+/opt/VirtualBoxAdditions/vboxguest.sh stopall silentunload
+
+# remove devlink.tab entry for vboxguest
+sed -e '
+/name=vboxguest/d' /etc/devlink.tab > /etc/devlink.vbox
+mv -f /etc/devlink.vbox /etc/devlink.tab
+
+# remove the link
+if test -h "/dev/vboxguest" || test -f "/dev/vboxguest"; then
+    rm -f /dev/vboxdrv
+fi
+if test -h "/dev/vboxms" || test -f "/dev/vboxms"; then
+    rm -f /dev/vboxms
+fi
+
+# Try and restore xorg.conf!
+echo "Restoring X.Org..."
+/opt/VirtualBoxAdditions/x11restore.pl
+
+
+echo "Done."
+
diff --git a/src/VBox/Additions/solaris/Installer/vbox_vendor_select b/src/VBox/Additions/solaris/Installer/vbox_vendor_select
new file mode 100755
index 00000000..0e788cfc
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vbox_vendor_select
@@ -0,0 +1,88 @@
+#!/bin/ksh93
+# $Id: vbox_vendor_select $
+## @file
+# ???
+#
+
+#
+# Copyright (C) 2013-2020 Oracle Corporation
+# This file is based on mesa_vendor_select from Solaris 11.3 with the following copyright:
+#
+# Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
+#
+# 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 (including the next
+# paragraph) 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.
+#
+
+LINKDIR=/system/volatile/opengl
+MESA_SELECT=/lib/opengl/ogl_select/mesa_vendor_select
+
+PATH=/usr/bin:/usr/sbin
+
+ARCH="$(uname -p)"
+
+case "${ARCH}" in
+    i386)			;;
+    *)		exit 1		;; # Unsupported architecture
+esac
+
+# We need Mesa for the parts we do not supply.
+if [[ ! -x "${MESA_SELECT}" ]]; then
+	exit 0
+fi
+
+if [[ $# -eq 1 ]] && [[ $1 == "identify" ]] ; then
+	# Probe time.  Check whether this system supports pass-through.
+	# If so, emit an identity string attaching us to the current
+	# console identifier.
+	if /usr/bin/VBoxClient --check3d ; then
+	    print "$(constype) vbox"
+	fi
+	return 0
+fi
+
+# Make a file link. $1 is the source path, $2 is the target path
+function make_link {
+	if [[ $# != 2 ]]; then
+		return
+	fi
+	if [[ -h $2 ]]; then
+		rm -f $2
+	fi
+	ln -sf $1 $2
+}
+
+# Start by setting up Mesa, as we use that for everything except the user
+# libraries.
+${MESA_SELECT}
+
+# User libraries
+if [[ -f ${LINKDIR}/lib/libGL.so.1 ]] && [[ -f /usr/lib/VBoxOGL.so ]] ; then
+	make_link /usr/lib/VBoxOGL.so ${LINKDIR}/lib/libGL.so.1
+fi
+if [[ -f ${LINKDIR}/lib/i386/libGL.so.1 ]] && \
+	[[ -f /usr/lib/i386/VBoxOGL.so ]] ; then
+	make_link /usr/lib/i386/VBoxOGL.so ${LINKDIR}/lib/i386/libGL.so.1
+fi
+if [[ -f ${LINKDIR}/lib/amd64/libGL.so.1 ]] && \
+	[[ -f /usr/lib/amd64/VBoxOGL.so ]] ; then
+	make_link /usr/lib/amd64/VBoxOGL.so ${LINKDIR}/lib/amd64/libGL.so.1
+fi
+
+return 0
diff --git a/src/VBox/Additions/solaris/Installer/vboxdevlink.sed b/src/VBox/Additions/solaris/Installer/vboxdevlink.sed
new file mode 100644
index 00000000..4511962e
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vboxdevlink.sed
@@ -0,0 +1,34 @@
+# $Id$
+## @file
+# sed class script to modify /etc/devlink.tab
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+!install
+/name=vboxguest/d
+$i\
+type=ddi_pseudo;name=vboxguest  \\D
+
+!remove
+/name=vboxguest/d
+
diff --git a/src/VBox/Additions/solaris/Installer/vboxguest.depend b/src/VBox/Additions/solaris/Installer/vboxguest.depend
new file mode 100644
index 00000000..68196355
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vboxguest.depend
@@ -0,0 +1 @@
+P SUNWuiu8 Iconv modules for UTF-8 Locale
diff --git a/src/VBox/Additions/solaris/Installer/vboxguest.pkginfo b/src/VBox/Additions/solaris/Installer/vboxguest.pkginfo
new file mode 100644
index 00000000..9456d0d4
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vboxguest.pkginfo
@@ -0,0 +1,15 @@
+PKG="SUNWvboxguest"
+NAME="@VBOX_PRODUCT@ Guest Additions"
+SUNW_PRODNAME="@VBOX_PRODUCT@ Guest Additions"
+ARCH="@UNAME_P@"
+VERSION="@VBOX_VERSION_STRING@,REV=r@VBOX_SVN_REV@.@VBOX_VERSION_REVSTAMP@"
+SUNW_PRODVERS="@VBOX_VERSION_STRING@"
+SUNW_PKGVERS=1.0
+CATEGORY="application"
+VENDOR="@VBOX_VENDOR@"
+EMAIL="info@virtualbox.org"
+HOTLINE="Please contact your local service provider"
+BASEDIR="/"
+CLASSES=none manifest
+DESC="@VBOX_PRODUCT@ Guest Additions for Solaris guests"
+
diff --git a/src/VBox/Additions/solaris/Installer/vboxguest.sh b/src/VBox/Additions/solaris/Installer/vboxguest.sh
new file mode 100755
index 00000000..6671bfe6
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vboxguest.sh
@@ -0,0 +1,252 @@
+#!/bin/sh
+# $Id: vboxguest.sh $
+## @file
+# VirtualBox Guest Additions kernel module control script for Solaris.
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+LC_ALL=C
+export LC_ALL
+
+LANG=C
+export LANG
+
+SILENTUNLOAD=""
+MODNAME="vboxguest"
+VFSMODNAME="vboxfs"
+VMSMODNAME="vboxms"
+MODDIR32="/usr/kernel/drv"
+MODDIR64="/usr/kernel/drv/amd64"
+VFSDIR32="/usr/kernel/fs"
+VFSDIR64="/usr/kernel/fs/amd64"
+
+abort()
+{
+    echo 1>&2 "## $1"
+    exit 1
+}
+
+info()
+{
+    echo 1>&2 "$1"
+}
+
+check_if_installed()
+{
+    cputype=`isainfo -k`
+    modulepath="$MODDIR32/$MODNAME"
+    if test "$cputype" = "amd64"; then
+        modulepath="$MODDIR64/$MODNAME"
+    fi
+    if test -f "$modulepath"; then
+        return 0
+    fi
+    abort "VirtualBox kernel module ($MODNAME) NOT installed."
+}
+
+module_loaded()
+{
+    if test -z "$1"; then
+        abort "missing argument to module_loaded()"
+    fi
+
+    modname=$1
+    # modinfo should now work properly since we prevent module autounloading.
+    loadentry=`/usr/sbin/modinfo | grep "$modname "`
+    if test -z "$loadentry"; then
+        return 1
+    fi
+    return 0
+}
+
+vboxguest_loaded()
+{
+    module_loaded $MODNAME
+    return $?
+}
+
+vboxfs_loaded()
+{
+    module_loaded $VFSMODNAME
+    return $?
+}
+
+vboxms_loaded()
+{
+    module_loaded $VMSMODNAME
+    return $?
+}
+
+check_root()
+{
+    # the reason we don't use "-u" is that some versions of id are old and do not
+    # support this option (eg. Solaris 10) and do not have a "--version" to check it either
+    # so go with the uglier but more generic approach
+    idbin=`which id`
+    isroot=`$idbin | grep "uid=0"`
+    if test -z "$isroot"; then
+        abort "This program must be run with administrator privileges.  Aborting"
+    fi
+}
+
+start_module()
+{
+    /usr/sbin/add_drv -i'pci80ee,cafe' -m'* 0666 root sys' $MODNAME
+    if test ! vboxguest_loaded; then
+        abort "Failed to load VirtualBox guest kernel module."
+    elif test -c "/devices/pci@0,0/pci80ee,cafe@4:$MODNAME"; then
+        info "VirtualBox guest kernel module loaded."
+    else
+        info "VirtualBox guest kernel module failed to attach."
+    fi
+}
+
+stop_module()
+{
+    if vboxguest_loaded; then
+        /usr/sbin/rem_drv $MODNAME || abort "Failed to unload VirtualBox guest kernel module."
+        info "VirtualBox guest kernel module unloaded."
+    elif test -z "$SILENTUNLOAD"; then
+        info "VirtualBox guest kernel module not loaded."
+    fi
+}
+
+start_vboxfs()
+{
+    if vboxfs_loaded; then
+        info "VirtualBox FileSystem kernel module already loaded."
+    else
+        /usr/sbin/modload -p fs/$VFSMODNAME || abort "Failed to load VirtualBox FileSystem kernel module."
+        if test ! vboxfs_loaded; then
+            info "Failed to load VirtualBox FileSystem kernel module."
+        else
+            info "VirtualBox FileSystem kernel module loaded."
+        fi
+    fi
+}
+
+stop_vboxfs()
+{
+    if vboxfs_loaded; then
+        vboxfs_mod_id=`/usr/sbin/modinfo | grep $VFSMODNAME | cut -f 1 -d ' ' `
+        if test -n "$vboxfs_mod_id"; then
+            /usr/sbin/modunload -i $vboxfs_mod_id || abort "Failed to unload VirtualBox FileSystem module."
+            info "VirtualBox FileSystem kernel module unloaded."
+        fi
+    elif test -z "$SILENTUNLOAD"; then
+        info "VirtualBox FileSystem kernel module not loaded."
+    fi
+}
+
+start_vboxms()
+{
+    /usr/sbin/add_drv -m'* 0666 root sys' $VMSMODNAME
+    if test ! vboxms_loaded; then
+        abort "Failed to load VirtualBox pointer integration module."
+    elif test -c "/devices/pseudo/$VMSMODNAME@0:$VMSMODNAME"; then
+        info "VirtualBox pointer integration module loaded."
+    else
+        info "VirtualBox pointer integration module failed to attach."
+    fi
+}
+
+stop_vboxms()
+{
+    if vboxms_loaded; then
+        /usr/sbin/rem_drv $VMSMODNAME || abort "Failed to unload VirtualBox pointer integration module."
+        info "VirtualBox pointer integration module unloaded."
+    elif test -z "$SILENTUNLOAD"; then
+        info "VirtualBox pointer integration module not loaded."
+    fi
+}
+
+status_module()
+{
+    if vboxguest_loaded; then
+        info "Running."
+    else
+        info "Stopped."
+    fi
+}
+
+stop_all()
+{
+    stop_vboxms
+    stop_vboxfs
+    stop_module
+    return 0
+}
+
+restart_all()
+{
+    stop_all
+    start_module
+    start_vboxfs
+    start_vboxms
+    return 0
+}
+
+check_root
+check_if_installed
+
+if test "$2" = "silentunload"; then
+    SILENTUNLOAD="$2"
+fi
+
+case "$1" in
+stopall)
+    stop_all
+    ;;
+restartall)
+    restart_all
+    ;;
+start)
+    start_module
+    start_vboxms
+    ;;
+stop)
+    stop_vboxms
+    stop_module
+    ;;
+status)
+    status_module
+    ;;
+vfsstart)
+    start_vboxfs
+    ;;
+vfsstop)
+    stop_vboxfs
+    ;;
+vmsstart)
+    start_vboxms
+    ;;
+vmsstop)
+    stop_vboxms
+    ;;
+*)
+    echo "Usage: $0 {start|stop|restart|status}"
+    exit 1
+esac
+
+exit 0
+
diff --git a/src/VBox/Additions/solaris/Installer/vboxguest.space b/src/VBox/Additions/solaris/Installer/vboxguest.space
new file mode 100644
index 00000000..993a6f6d
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vboxguest.space
@@ -0,0 +1,5 @@
+# Space file for VirtualBox Guest Additions installer
+# We only create a few links and copy a few files, reserve some space
+# pathname blocks inodes
+/ 5000 8
+
diff --git a/src/VBox/Additions/solaris/Installer/vboxservice.xml b/src/VBox/Additions/solaris/Installer/vboxservice.xml
new file mode 100644
index 00000000..270c23f1
--- /dev/null
+++ b/src/VBox/Additions/solaris/Installer/vboxservice.xml
@@ -0,0 +1,76 @@
+<?xml version='1.0'?>
+<!--
+#
+# Solaris SMF service manifest for VBoxService (timesync).
+#
+    Copyright (C) 2008-2020 Oracle Corporation
+
+    This file is part of VirtualBox Open Source Edition (OSE), as
+    available from http://www.virtualbox.org. This file is free software;
+    you can redistribute it and/or modify it under the terms of the GNU
+    General Public License (GPL) as published by the Free Software
+    Foundation, in version 2 as it comes in the "COPYING" file of the
+    VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+    hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+
+    The contents of this file may alternatively be used under the terms
+    of the Common Development and Distribution License Version 1.0
+    (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+    VirtualBox OSE distribution, in which case the provisions of the
+    CDDL are applicable instead of those of the GPL.
+
+    You may elect to license modified versions of this file under the
+    terms and conditions of either the GPL or the CDDL or both.
+-->
+<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
+
+<service_bundle type='manifest' name='SUNWvboxguest:vboxservice'>
+
+<service
+    name='application/virtualbox/vboxservice'
+    type='service'
+    version='1'>
+
+    <create_default_instance enabled='false' />
+
+    <single_instance/>
+
+    <!-- Wait for devices to be initialized as we depend on vboxguest (PCI) -->
+    <dependency
+        name='milestone'
+        grouping='require_all'
+        restart_on='none'
+        type='service'>
+        <service_fmri value='svc:/milestone/devices:default' />
+    </dependency>
+
+    <!-- Wait for local filesystems to be mounted (just to be safe, don't start too early) -->
+    <dependency
+        name='filesystem-local'
+        grouping='require_all'
+        restart_on='none'
+        type='service'>
+        <service_fmri value='svc:/system/filesystem/local:default' />
+    </dependency>
+
+    <exec_method
+        type='method'
+        name='start'
+        exec='/usr/bin/VBoxService'
+        timeout_seconds='30' />
+
+    <exec_method
+        type='method'
+        name='stop'
+        exec=':kill'
+        timeout_seconds='60' />
+
+    <template>
+        <common_name>
+            <loctext xml:lang='C'>VirtualBox Service.</loctext>
+        </common_name>
+    </template>
+</service>
+
+</service_bundle>
+
diff --git a/src/VBox/Additions/solaris/Makefile.kmk b/src/VBox/Additions/solaris/Makefile.kmk
new file mode 100644
index 00000000..e463f379
--- /dev/null
+++ b/src/VBox/Additions/solaris/Makefile.kmk
@@ -0,0 +1,402 @@
+# $Id: Makefile.kmk $
+## @file
+# Makefile for the Solaris guest additions base directory.
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+SUB_DEPTH = ../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#ifneq ($(KBUILD_HOST),solaris)
+#$(error "The Solaris guest additions installer can only be built on Solaris!")
+#endif
+
+ifeq ($(KBUILD_TARGET),solaris)
+ include $(PATH_SUB_CURRENT)/SharedFolders/Makefile.kmk
+ include $(PATH_SUB_CURRENT)/Mouse/Makefile.kmk
+ include $(PATH_SUB_CURRENT)/DRM/Makefile.kmk
+endif
+
+ifdef VBOX_WITH_COMBINED_SOLARIS_PACKAGE ## @todo remove this when tinderclient.pl is updated.
+ VBOX_WITH_COMBINED_GUEST_PACKAGE := 1
+endif
+
+PKGFILENAME                             := VBoxSolarisAdditions.pkg
+PKGINFO_ARCH                             = $(shell uname -p)
+PKGINFO_REVSTAMP                         = $(date %Y.%m.%d.%H.%M)
+VBOX_PATH_SOLARIS_ADDITION_INSTALLER    := $(PATH_SUB_CURRENT)/Installer
+VBOX_PATH_X11_ADDITION_INSTALLER        := $(PATH_ROOT)/src/VBox/Additions/x11/Installer
+
+SOLARIS_ADDDIR_NAME_64                  := amd64
+SOLARIS_ADDDIR_NAME_32                  := i386
+
+SOLARIS_ADDINST_OUT_DIR                 := $(PATH_TARGET)/AdditionsInstaller
+SOLARIS_VBOXADDINST_SUBDIR              := /opt/VirtualBoxAdditions
+SOLARIS_VBOXADDINST_DIR                 := $(SOLARIS_ADDINST_OUT_DIR)$(SOLARIS_VBOXADDINST_SUBDIR)
+SOLARIS_VBOXADDINST_DIR_32              := $(SOLARIS_VBOXADDINST_DIR)/$(SOLARIS_ADDDIR_NAME_32)
+SOLARIS_VBOXADDINST_DIR_64              := $(SOLARIS_VBOXADDINST_DIR)/$(SOLARIS_ADDDIR_NAME_64)
+
+SOLARIS_ADD_OUT_BIN_64                  := $(PATH_OUT_BASE)/solaris.amd64/$(KBUILD_TYPE)/bin/additions
+SOLARIS_ADD_OUT_BIN_32                  := $(PATH_OUT_BASE)/solaris.x86/$(KBUILD_TYPE)/bin/additions
+SOLARIS_ADD_OUT_BIN_ISA                 := $(PATH_OUT_BASE)/solaris.$(KBUILD_TARGET_ARCH)/$(KBUILD_TYPE)/bin/additions
+
+SOLARIS_ADD_DRIVERINST_DIR              := $(SOLARIS_ADDINST_OUT_DIR)/usr/kernel/drv
+SOLARIS_ADD_DRIVERINST_DIR_32           := $(SOLARIS_ADD_DRIVERINST_DIR)
+SOLARIS_ADD_DRIVERINST_DIR_64           := $(SOLARIS_ADD_DRIVERINST_DIR)/amd64
+
+SOLARIS_ADD_SYSLIBINST_DIR_32           := $(SOLARIS_ADDINST_OUT_DIR)/usr/lib
+SOLARIS_ADD_SYSLIBINST_DIR_64           := $(SOLARIS_ADDINST_OUT_DIR)/usr/lib/amd64
+
+SOLARIS_ADD_USRBIN_DIR                  := $(SOLARIS_ADDINST_OUT_DIR)/usr/bin
+SOLARIS_ADD_USRSBIN_DIR                 := $(SOLARIS_ADDINST_OUT_DIR)/usr/sbin
+SOLARIS_ADD_ETCFS_DIR                   := $(SOLARIS_ADDINST_OUT_DIR)/etc/fs/vboxfs
+SOLARIS_ADD_SERVICESINST_DIR            := $(SOLARIS_ADDINST_OUT_DIR)/var/svc/manifest/application/virtualbox
+
+ifeq ($(KBUILD_TARGET_ARCH),x86)
+ SOLARIS_ADDDIR_NAME_ISA                := $(SOLARIS_ADDDIR_NAME_32)
+ SOLARIS_VBOXADDINST_DIR_ISA            := $(SOLARIS_VBOXADDINST_DIR_32)
+ SOLARIS_ADD_DRIVERINST_DIR_ISA         := $(SOLARIS_ADD_DRIVERINST_DIR_32)
+ SOLARIS_ADD_SYSLIBINST_DIR_ISA         := $(SOLARIS_ADD_SYSLIBINST_DIR_32)
+else
+ SOLARIS_ADDDIR_NAME_ISA                := $(SOLARIS_ADDDIR_NAME_64)
+ SOLARIS_VBOXADDINST_DIR_ISA            := $(SOLARIS_VBOXADDINST_DIR_64)
+ SOLARIS_ADD_DRIVERINST_DIR_ISA         := $(SOLARIS_ADD_DRIVERINST_DIR_64)
+ SOLARIS_ADD_SYSLIBINST_DIR_ISA         := $(SOLARIS_ADD_SYSLIBINST_DIR_64)
+endif
+
+ifeq ($(KBUILD_TYPE),debug)
+ BIN_COPY         := $(CP) -f
+ BIN_COPY_SYMBOLS := $(CP) -f
+else
+ BIN_COPY         := /usr/sfw/bin/gobjcopy -S -R .comment
+ BIN_COPY_SYMBOLS := /usr/sfw/bin/gobjcopy -g -R .comment
+ VBOX_COMPRESS    := compress -f
+endif
+
+INSTALLS          += solaris-addcommon solaris-addcommonbins
+PROGRAMS          += VBoxAddISAExec
+PACKING           += $(PATH_STAGE_BIN)/additions/$(PKGFILENAME)
+OTHER_CLEAN       += $(PACKING) $(SOLARIS_ADDINST_OUT_DIR)/$(PKGFILENAME)
+
+#
+# VBoxAddISAExec
+#
+VBoxAddISAExec_TEMPLATE = VBOXR3EXE
+VBoxAddISAExec_NAME     = VBoxISAExec
+VBoxAddISAExec_INST     = $(INST_ADDITIONS)
+VBoxAddISAExec_DEPS     = $(VBOX_SVN_REV_KMK)
+VBoxAddISAExec_SOURCES  = $(PATH_ROOT)/src/VBox/Installer/solaris/VBoxISAExec.c
+
+#
+# Install to $(PATH_STAGE_BIN)/additions/ files from various source paths (to pack them using rules)
+#
+solaris-addcommonbins_INST = bin/additions/
+solaris-addcommonbins_MODE = a+rx,u+w
+solaris-addcommonbins_SOURCES = \
+	$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.sh \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/x11config.pl \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/x11config15sol.pl \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/x11restore.pl \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/98vboxadd-xclient=>1099.vboxclient \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/solaris_xorg.conf \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/solaris_xorg_modeless.conf \
+	$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vbox_vendor_select \
+	$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/VBox.sh
+
+solaris-addcommon_INST = bin/additions/
+solaris-addcommon_MODE = a+r,u+w
+solaris-addcommon_SOURCES = \
+	$(PATH_ROOT)/src/VBox/Additions/common/VBoxGuest/VBoxGuest-solaris.conf=>vboxguest.conf \
+	$(PATH_ROOT)/src/VBox/Additions/solaris/Mouse/vboxms.conf=>vboxms.conf \
+	$(VBOX_PATH_X11_ADDITION_INSTALLER)/vboxclient.desktop \
+	$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxservice.xml \
+	$(PATH_ROOT)/src/VBox/Additions/solaris/Mouse/vboxmslnk.xml \
+	$(VBOX_BRAND_LICENSE_TXT)=>LICENSE
+
+#
+# Create full directory tree
+#
+BLDDIRS          += \
+	$(SOLARIS_ADDINST_OUT_DIR) \
+	$(addprefix $(SOLARIS_ADDINST_OUT_DIR)/,\
+	opt \
+	opt/VirtualBoxAdditions \
+	opt/VirtualBoxAdditions/$(SOLARIS_ADDDIR_NAME_32) \
+	opt/VirtualBoxAdditions/$(SOLARIS_ADDDIR_NAME_64) \
+	usr \
+	usr/bin \
+	usr/sbin \
+	usr/lib \
+	usr/lib/amd64 \
+	usr/kernel \
+	usr/kernel/drv \
+	usr/kernel/drv/amd64 \
+	var \
+	var/svc \
+	var/svc/manifest \
+	var/svc/manifest/application \
+	var/svc/manifest/application/virtualbox \
+	)
+
+SOLARIS_ADD_STRIP_BINS = \
+	VBoxClient \
+	VBoxService \
+	VBoxControl \
+	vboxfsmount \
+	vboxfs \
+	vboxmslnk \
+	$(if ($VBOX_WITH_PAM),pam_vbox.so,) \
+	$(if $(VBOX_OSE),,vboxfs_s10)
+
+SOLARIS_ADD_DRIVERS = \
+	vboxguest \
+	vboxms
+
+SOLARIS_ADD_DRIVERS_CONF = \
+	vboxguest.conf \
+	vboxms.conf
+
+SOLARIS_ADD_XORG_DRIVERS = \
+	vboxvideo_drv_13.so \
+	vboxvideo_drv_14.so \
+	vboxvideo_drv_15.so \
+	vboxvideo_drv_16.so \
+	vboxvideo_drv_17.so \
+	vboxvideo_drv_18.so \
+	vboxvideo_drv_19.so \
+	vboxvideo_drv_110.so \
+	vboxvideo_drv_111.so \
+	vboxvideo_drv_112.so \
+	vboxvideo_drv_113.so \
+	vboxvideo_drv_114.so \
+	vboxvideo_drv_117.so \
+	vboxvideo_drv_118.so \
+	vboxvideo_drv_70.so \
+	vboxvideo_drv_71.so
+
+SOLARIS_ADD_COMMON_BINS = \
+	vboxguest.sh \
+	x11config15sol.pl \
+	x11restore.pl \
+	VBox.sh \
+	1099.vboxclient \
+	vbox_vendor_select \
+	VBoxISAExec
+
+SOLARIS_ADD_USRBIN_LINKS = \
+	VBoxService \
+	VBoxClient \
+	VBoxControl
+
+SOLARIS_ADD_USRSBIN_LINKS = \
+	vboxmslnk
+
+SOLARIS_ADD_COMMON = \
+	vboxclient.desktop \
+	solaris_xorg.conf \
+	solaris_xorg_modeless.conf \
+	LICENSE
+
+SOLARIS_ADD_SERVICES = \
+	vboxservice.xml \
+	vboxmslnk.xml
+
+ifdef VBOX_COMPRESS
+ SOLARIS_ADD_COMPRESS_FILES = \
+	$(SOLARIS_ADD_XORG_DRIVERS) \
+	VBoxService \
+	VBoxClient \
+	VBoxControl
+endif
+
+ifdef VBOX_WITH_COMBINED_SOLARIS_GUEST_PACKAGE
+  SOLARIS_ARCH_ADD_DEPFILES = \
+   $(addprefix $(SOLARIS_VBOXADDINST_DIR_64)/,$(SOLARIS_ADD_STRIP_BINS)) \
+	$(addprefix $(SOLARIS_VBOXADDINST_DIR_64)/,$(SOLARIS_ADD_XORG_DRIVERS)) \
+	$(addprefix $(SOLARIS_VBOXADDINST_DIR_32)/,$(SOLARIS_ADD_STRIP_BINS)) \
+	$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR_64)/,$(SOLARIS_ADD_DRIVERS)) \
+	$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR_32)/,$(SOLARIS_ADD_DRIVERS)) \
+	$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR)/,$(SOLARIS_ADD_DRIVERS_CONF)) \
+	$(addprefix $(SOLARIS_VBOXADDINST_DIR_32)/,$(SOLARIS_ADD_XORG_DRIVERS))
+else
+  SOLARIS_ARCH_ADD_DEPFILES = \
+   $(addprefix $(SOLARIS_VBOXADDINST_DIR_ISA)/,$(SOLARIS_ADD_STRIP_BINS)) \
+	$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR_ISA)/,$(SOLARIS_ADD_DRIVERS)) \
+	$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR)/,$(SOLARIS_ADD_DRIVERS_CONF)) \
+	$(addprefix $(SOLARIS_VBOXADDINST_DIR_ISA)/,$(SOLARIS_ADD_XORG_DRIVERS))
+endif
+
+SOLARIS_ARCH_ADD_DEPFILES += \
+	$(addprefix $(SOLARIS_VBOXADDINST_DIR)/,$(SOLARIS_ADD_COMMON_BINS)) \
+	$(addprefix $(SOLARIS_VBOXADDINST_DIR)/,$(SOLARIS_ADD_COMMON)) \
+	$(addprefix $(SOLARIS_ADD_SERVICESINST_DIR)/,$(SOLARIS_ADD_SERVICES)) \
+	$(addprefix $(SOLARIS_ADD_USRBIN_DIR)/,$(SOLARIS_ADD_USRBIN_LINKS)) \
+	$(addprefix $(SOLARIS_ADD_USRSBIN_DIR)/,$(SOLARIS_ADD_USRSBIN_LINKS))
+
+
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
+#
+# -=-=-=-=-=-=-=- Additions package -=-=-=-=-=-=-=-
+#
+
+$(PATH_STAGE_BIN)/additions/$(PKGFILENAME): \
+		$(VBOX_VERSION_STAMP) \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/makepackage.sh \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/postinstall.sh \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/preremove.sh \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.pkginfo \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.depend \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.sh \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxservice.xml \
+		$(PATH_ROOT)/src/VBox/Additions/solaris/Mouse/vboxmslnk.xml \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/VBox.sh \
+		$(VBOX_PATH_X11_ADDITION_INSTALLER)/98vboxadd-xclient \
+		$(VBOX_PATH_X11_ADDITION_INSTALLER)/x11config15sol.pl \
+		$(VBOX_PATH_X11_ADDITION_INSTALLER)/x11restore.pl \
+		$(VBOX_PATH_X11_ADDITION_INSTALLER)/solaris_xorg.conf \
+		$(VBOX_PATH_X11_ADDITION_INSTALLER)/solaris_xorg_modeless.conf \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vbox_vendor_select \
+		$(VBOX_BRAND_LICENSE_TXT) \
+		$(PATH_ROOT)/src/VBox/Additions/common/VBoxGuest/VBoxGuest-solaris.conf \
+		$(PATH_SUB_CURRENT)/solaris/Makefile.kmk \
+		$(SOLARIS_ARCH_ADD_DEPFILES)
+	$(call MSG_L1,Installing guest additions)
+	$(QUIET)$(SED) \
+		-e "s/@VBOX_PRODUCT@/$(VBOX_PRODUCT)/g" \
+		-e "s/@VBOX_VENDOR@/$(VBOX_VENDOR)/g" \
+		-e "s/@VBOX_VERSION_STRING@/$(VBOX_VERSION_STRING)/g" \
+		-e "s/@VBOX_SVN_REV@/$(VBOX_SVN_REV)/g" \
+		-e "s/@VBOX_VERSION_REVSTAMP@/$(PKGINFO_REVSTAMP)/g" \
+		-e "s/@UNAME_P@/$(PKGINFO_ARCH)/g" \
+		--output $(SOLARIS_ADDINST_OUT_DIR)/vboxguest.pkginfo \
+		$(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.pkginfo
+	$(QUIET)$(INSTALL) -m 0755 $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/makepackage.sh                     $(SOLARIS_ADDINST_OUT_DIR)/makepackage.sh
+	$(QUIET)$(INSTALL) -m 0755 $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/postinstall.sh                     $(SOLARIS_ADDINST_OUT_DIR)/postinstall.sh
+	$(QUIET)$(INSTALL) -m 0755 $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/preremove.sh                       $(SOLARIS_ADDINST_OUT_DIR)/preremove.sh
+	$(QUIET)$(INSTALL) -m 0644 $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.space                    $(SOLARIS_ADDINST_OUT_DIR)/vboxguest.space
+	$(QUIET)$(INSTALL) -m 0644 $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxguest.depend                   $(SOLARIS_ADDINST_OUT_DIR)/vboxguest.depend
+	# don't display the license on package install, since 4.0
+	#$(QUIET)$(INSTALL) -m 0644 $(VBOX_BRAND_LICENSE_TXT)                                                  $(SOLARIS_ADDINST_OUT_DIR)/vboxguest.copyright
+	$(call MSG_L1,Creating install package: $@)
+	$(QUIET)$(MKDIR) -p $(SOLARIS_ADD_ETCFS_DIR)
+	$(QUIET)$(MKDIR) -p $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)
+	$(QUIET)$(LN_SYMLINK) -f ../..$(SOLARIS_VBOXADDINST_SUBDIR)/1099.vboxclient                           $(SOLARIS_ADD_USRBIN_DIR)/VBoxClient-all
+ifdef VBOX_WITH_COMBINED_SOLARIS_GUEST_PACKAGE
+ ifdef VBOX_COMPRESS
+	$(QUIET)$(VBOX_COMPRESS) $(addprefix $(SOLARIS_VBOXADDINST_DIR_32)/,$(SOLARIS_ADD_COMPRESS_FILES))
+	$(QUIET)$(VBOX_COMPRESS) $(addprefix $(SOLARIS_VBOXADDINST_DIR_64)/,$(SOLARIS_ADD_COMPRESS_FILES))
+ endif
+	$(QUIET)$(LN_SYMLINK) -f ../../..$(SOLARIS_VBOXADDINST_SUBDIR)/$(SOLARIS_ADDDIR_NAME_32)/vboxfsmount  $(SOLARIS_ADD_ETCFS_DIR)/mount
+else # !VBOX_WITH_COMBINED_SOLARIS_GUEST_PACKAGE
+ ifdef VBOX_COMPRESS
+	$(QUIET)$(VBOX_COMPRESS) $(addprefix $(SOLARIS_VBOXADDINST_DIR_ISA)/,$(SOLARIS_ADD_COMPRESS_FILES))
+ endif
+	$(LN_SYMLINK) -f ../../..$(SOLARIS_VBOXADDINST_SUBDIR)/$(SOLARIS_ADDDIR_NAME_ISA)/vboxfsmount         $(SOLARIS_ADD_ETCFS_DIR)/mount
+endif
+	$(QUIET)$(INSTALL) -m 0644 $(VBOX_PATH_SOLARIS_ADDITION_INSTALLER)/vboxservice.xml                    $(SOLARIS_ADD_SERVICESINST_DIR)/vboxservice.xml
+	$(QUIET)$(INSTALL) -m 0644 	$(PATH_ROOT)/src/VBox/Additions/solaris/Mouse/vboxmslnk.xml                      $(SOLARIS_ADD_SERVICESINST_DIR)/vboxmslnk.xml
+	$(QUIET)$(SOLARIS_ADDINST_OUT_DIR)/makepackage.sh $(SOLARIS_ADDINST_OUT_DIR) $(PKGFILENAME) $(VBOX_SVN_REV) $(VBOX_SOL_PKG_DEV)
+	$(QUIET)$(INSTALL) -m 0644 $(SOLARIS_ADDINST_OUT_DIR)/$(PKGFILENAME) $(PATH_STAGE_BIN)/additions/$(PKGFILENAME)
+	$(QUIET)$(RM) -f $(SOLARIS_ADDINST_OUT_DIR)/$(PKGFILENAME)
+
+
+
+#
+# -=-=-=-=-=-=-=- Package rules -=-=-=-=-=-=-=-
+#
+
+#
+# 32-bit files
+#
+$(addprefix $(SOLARIS_VBOXADDINST_DIR_32)/,$(SOLARIS_ADD_STRIP_BINS)): \
+		$(SOLARIS_VBOXADDINST_DIR_32)/% : $(SOLARIS_ADD_OUT_BIN_32)/% | $$(dir $$@)
+	$(INSTALL) -m 0755 $(if $(VBOX_DO_STRIP),-s,) $< $@
+
+$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR_32)/,$(SOLARIS_ADD_DRIVERS)): \
+		$(SOLARIS_ADD_DRIVERINST_DIR_32)/% : $(SOLARIS_ADD_OUT_BIN_32)/% | $$(dir $$@)
+	$(INSTALL) -m 0644 $< $@
+
+$(addprefix $(SOLARIS_VBOXADDINST_DIR_32)/,$(SOLARIS_ADD_XORG_DRIVERS)): \
+		$(SOLARIS_VBOXADDINST_DIR_32)/% : $(SOLARIS_ADD_OUT_BIN_32)/% | $$(dir $$@)
+	$(BIN_COPY) $< $@
+
+
+#
+# 64-bit files
+#
+$(addprefix $(SOLARIS_VBOXADDINST_DIR_64)/,$(SOLARIS_ADD_STRIP_BINS)): \
+		$(SOLARIS_VBOXADDINST_DIR_64)/% : $(SOLARIS_ADD_OUT_BIN_64)/% | $$(dir $$@)
+	$(INSTALL) -m 0755 $(if $(VBOX_DO_STRIP),-s,) $< $@
+
+$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR_64)/,$(SOLARIS_ADD_DRIVERS)): \
+		$(SOLARIS_ADD_DRIVERINST_DIR_64)/% : $(SOLARIS_ADD_OUT_BIN_64)/% | $$(dir $$@)
+	$(INSTALL) -m 0644 $< $@
+
+$(addprefix $(SOLARIS_VBOXADDINST_DIR_64)/,$(SOLARIS_ADD_XORG_DRIVERS)): \
+		$(SOLARIS_VBOXADDINST_DIR_64)/% : $(SOLARIS_ADD_OUT_BIN_64)/% | $$(dir $$@)
+	$(BIN_COPY) $< $@
+
+
+#
+# Common files
+#
+$(addprefix $(SOLARIS_VBOXADDINST_DIR)/,$(SOLARIS_ADD_COMMON)): \
+		$(SOLARIS_VBOXADDINST_DIR)/% : $(SOLARIS_ADD_OUT_BIN_ISA)/% | $$(dir $$@)
+	$(INSTALL) -m 0644 $< $@
+
+#
+# Common binaries/shell scripts
+#
+$(addprefix $(SOLARIS_VBOXADDINST_DIR)/,$(SOLARIS_ADD_COMMON_BINS)): \
+		$(SOLARIS_VBOXADDINST_DIR)/% : $(SOLARIS_ADD_OUT_BIN_ISA)/% | $$(dir $$@)
+	$(INSTALL) -m 0755 $< $@
+
+#
+# Driver .conf files
+#
+$(addprefix $(SOLARIS_ADD_DRIVERINST_DIR)/,$(SOLARIS_ADD_DRIVERS_CONF)): \
+		$(SOLARIS_ADD_DRIVERINST_DIR)/% : $(SOLARIS_ADD_OUT_BIN_ISA)/% | $$(dir $$@)
+	$(INSTALL) -m 0644 $< $@
+
+#
+# SMF Service files
+#
+$(addprefix $(SOLARIS_ADD_SERVICESINST_DIR)/,$(SOLARIS_ADD_SERVICES)): \
+		$(SOLARIS_ADD_SERVICESINST_DIR)/% : $(SOLARIS_ADD_OUT_BIN_ISA)/% | $$(dir $$@)
+	$(INSTALL) -m 0644 $< $@
+
+#
+# Symlinks from /usr/bin/ to /opt/VirtualBoxAdditions
+#
+$(addprefix $(SOLARIS_ADD_USRBIN_DIR)/,$(SOLARIS_ADD_USRBIN_LINKS)): \
+		$(SOLARIS_ADD_USRBIN_DIR)/% : % | $$(dir $$@)
+	$(LN_SYMLINK) -f ../..$(SOLARIS_VBOXADDINST_SUBDIR)/$< $@
+
+#
+# Symlinks from /usr/sbin/ to /opt/VirtualBoxAdditions
+#
+$(addprefix $(SOLARIS_ADD_USRSBIN_DIR)/,$(SOLARIS_ADD_USRSBIN_LINKS)): \
+		$(SOLARIS_ADD_USRSBIN_DIR)/% : % | $$(dir $$@)
+	$(LN_SYMLINK) -f ../..$(SOLARIS_VBOXADDINST_SUBDIR)/$< $@
diff --git a/src/VBox/Additions/solaris/Mouse/Makefile.kmk b/src/VBox/Additions/solaris/Mouse/Makefile.kmk
new file mode 100644
index 00000000..366e60b0
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/Makefile.kmk
@@ -0,0 +1,71 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the Solaris Mouse Integration kernel module.
+#
+
+#
+# Copyright (C) 2012-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+SUB_DEPTH = ../../../../..
+include	$(KBUILD_PATH)/subheader.kmk
+
+#ifneq ($(KBUILD_HOST),solaris)
+#$(error "The Solaris guest additions can only be built on Solaris!")
+#endif
+
+#
+# vboxms - The Mouse Integration Driver
+#
+SYSMODS.solaris     += vboxms
+vboxms_TEMPLATE   = VBOXGUESTR0
+vboxms_DEFS       = VBOX_WITH_HGCM VBOX_SVN_REV=$(VBOX_SVN_REV)
+vboxms_DEPS      += $(VBOX_SVN_REV_KMK)
+vboxms_SOURCES    = \
+	vboxms.c
+vboxms_LIBS       = \
+	$(VBOX_LIB_VBGL_R0)
+ifeq ($(KBUILD_HOST),solaris)
+ vboxms_LDFLAGS         += -N drv/vboxguest -N misc/ctf
+else
+ vboxms_SOURCES         += deps.asm
+ vboxms_deps.asm_ASFLAGS = -f bin -g null
+endif
+
+
+PROGRAMS += vboxmslnk
+vboxmslnk_TEMPLATE    = NewVBoxGuestR3Exe
+vboxmslnk_SOURCES     = vboxmslnk.c
+
+
+if 0 # Broken - unresolved externals: vbglDriver*, RTR0AssertPanicSystem.
+if defined(VBOX_WITH_TESTCASES) && !defined(VBOX_ONLY_ADDITIONS) && !defined(VBOX_ONLY_SDK)
+ PROGRAMS += tstVBoxMouse-solaris
+ tstVBoxMouse-solaris_TEMPLATE = VBOXR3TSTEXE
+ tstVBoxMouse-solaris_SOURCES  = \
+ 	vboxms.c \
+ 	testcase/tstVBoxMouse-solaris.c
+ tstVBoxMouse-solaris_DEFS     = TESTCASE
+ tstVBoxMouse-solaris_LIBS     = $(LIB_RUNTIME)
+endif
+endif
+
+include	$(KBUILD_PATH)/subfooter.kmk
+
diff --git a/src/VBox/Additions/solaris/Mouse/deps.asm b/src/VBox/Additions/solaris/Mouse/deps.asm
new file mode 100644
index 00000000..8cd46f5f
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/deps.asm
@@ -0,0 +1,39 @@
+; $Id: deps.asm $
+;; @file
+; Solaris kernel module dependency
+;
+
+;
+; Copyright (C) 2012-2020 Oracle Corporation
+;
+; This file is part of VirtualBox Open Source Edition (OSE), as
+; available from http://www.virtualbox.org. This file is free software;
+; you can redistribute it and/or modify it under the terms of the GNU
+; General Public License (GPL) as published by the Free Software
+; Foundation, in version 2 as it comes in the "COPYING" file of the
+; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+; VirtualBox OSE distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+
+%include "iprt/solaris/kmoddeps.mac"
+
+kmoddeps_header  ; ELF header, section table and shared string table
+
+kmoddeps_dynstr_start  ; ELF .dynstr section
+kmoddeps_dynstr_string str_misc_ctf, "misc/ctf"
+kmoddeps_dynstr_string str_drv_vboxguest, "drv/vboxguest"
+kmoddeps_dynstr_end
+
+kmoddeps_dynamic_start  ; ELF .dynamic section
+kmoddeps_dynamic_needed str_misc_ctf
+kmoddeps_dynamic_needed str_drv_vboxguest
+kmoddeps_dynamic_end
diff --git a/src/VBox/Additions/solaris/Mouse/testcase/Makefile.kup b/src/VBox/Additions/solaris/Mouse/testcase/Makefile.kup
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/testcase/Makefile.kup
diff --git a/src/VBox/Additions/solaris/Mouse/testcase/solaris.h b/src/VBox/Additions/solaris/Mouse/testcase/solaris.h
new file mode 100644
index 00000000..bbc04129
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/testcase/solaris.h
@@ -0,0 +1,444 @@
+/* $Id: solaris.h $ */
+/** @file
+ * VBoxGuest - Guest Additions Driver for Solaris - testcase stubs.
+ */
+
+/*
+ * Copyright (C) 2012-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_Mouse_testcase_solaris_h
+#define GA_INCLUDED_SRC_solaris_Mouse_testcase_solaris_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/assert.h>
+#include <iprt/string.h>  /* RT_ZERO */
+#ifdef RT_OS_WINDOWS
+# include <iprt/win/winsock2.h>  /* struct timeval */
+#endif
+#include <errno.h>
+#include <time.h>  /* struct timeval */
+
+/* Overrides */
+#define dev_t unsigned
+
+/* Constants */
+#define DDI_FAILURE (-1)
+#define DDI_SUCCESS (0)
+
+#define MODMAXNAMELEN 32
+#define MODMAXLINKINFOLEN 32
+#define MODMAXLINK 10
+
+#define MOD_NOAUTOUNLOAD        0x1
+
+#define M_DATA          0x00
+#define M_BREAK         0x08
+#define M_PASSFP        0x09
+#define M_EVENT         0x0a
+#define M_SIG           0x0b
+#define M_DELAY         0x0c
+#define M_CTL           0x0d
+#define M_IOCTL         0x0e
+#define M_SETOPTS       0x10
+#define M_RSE           0x11
+
+#define M_IOCACK        0x81
+#define M_IOCNAK        0x82
+#define M_PCPROTO       0x83
+#define M_PCSIG         0x84
+#define M_READ          0x85
+#define M_FLUSH         0x86
+#define M_STOP          0x87
+#define M_START         0x88
+#define M_HANGUP        0x89
+#define M_ERROR         0x8a
+#define M_COPYIN        0x8b
+#define M_COPYOUT       0x8c
+#define M_IOCDATA       0x8d
+#define M_PCRSE         0x8e
+#define M_STOPI         0x8f
+#define M_STARTI        0x90
+#define M_PCEVENT       0x91
+#define M_UNHANGUP      0x92
+#define M_CMD           0x93
+
+#define BPRI_LO         1
+#define BPRI_MED        2
+#define BPRI_HI         3
+
+#define FLUSHALL        1
+#define FLUSHDATA       0
+
+#define TRANSPARENT     (unsigned int)(-1)
+
+#define FLUSHR          0x01
+#define FLUSHW          0x02
+
+#define MSIOC           ('m'<<8)
+#define MSIOGETPARMS    (MSIOC|1)
+#define MSIOSETPARMS    (MSIOC|2)
+#define MSIOBUTTONS     (MSIOC|3)
+#define MSIOSRESOLUTION (MSIOC|4)
+
+#define VUIOC           ('v'<<8)
+#define VUIDSFORMAT   (VUIOC|1)
+#define VUIDGFORMAT   (VUIOC|2)
+#define VUID_NATIVE     0
+#define VUID_FIRM_EVENT 1
+
+#define VUIDSADDR   (VUIOC|3)
+#define VUIDGADDR   (VUIOC|4)
+
+#define VUID_WHEEL_MAX_COUNT    256
+#define VUIDGWHEELCOUNT         (VUIOC|15)
+#define VUIDGWHEELINFO          (VUIOC|16)
+#define VUIDGWHEELSTATE         (VUIOC|17)
+#define VUIDSWHEELSTATE         (VUIOC|18)
+
+#define DDI_DEVICE_ATTR_V0      0x0001
+#define DDI_DEVICE_ATTR_V1      0x0002
+
+#define  DDI_NEVERSWAP_ACC      0x00
+#define  DDI_STRUCTURE_LE_ACC   0x01
+#define  DDI_STRUCTURE_BE_ACC   0x02
+
+#define DDI_STRICTORDER_ACC     0x00
+#define DDI_UNORDERED_OK_ACC    0x01
+#define DDI_MERGING_OK_ACC      0x02
+#define DDI_LOADCACHING_OK_ACC  0x03
+#define DDI_STORECACHING_OK_ACC 0x04
+
+/** @todo fix this */
+#define DDI_DEFAULT_ACC DDI_STRICTORDER_ACC
+
+#define DDI_INTR_CLAIMED        1
+#define DDI_INTR_UNCLAIMED      0
+
+#define DDI_INTR_TYPE_FIXED     0x1
+#define DDI_INTR_TYPE_MSI       0x2
+#define DDI_INTR_TYPE_MSIX      0x4
+
+#define LOC_FIRST_DELTA         32640
+#define LOC_X_DELTA             32640
+#define LOC_Y_DELTA             32641
+#define LOC_LAST_DELTA          32641
+#define LOC_FIRST_ABSOLUTE      32642
+#define LOC_X_ABSOLUTE          32642
+#define LOC_Y_ABSOLUTE          32643
+#define LOC_LAST_ABSOLUTE       32643
+
+#define FE_PAIR_NONE            0
+#define FE_PAIR_SET             1
+#define FE_PAIR_DELTA           2
+#define FE_PAIR_ABSOLUTE        3
+
+typedef struct __ldi_handle             *ldi_handle_t;
+
+typedef enum
+{
+    DDI_INFO_DEVT2DEVINFO = 0,
+    DDI_INFO_DEVT2INSTANCE = 1
+} ddi_info_cmd_t;
+
+typedef enum
+{
+    DDI_ATTACH = 0,
+    DDI_RESUME = 1,
+    DDI_PM_RESUME = 2
+} ddi_attach_cmd_t;
+
+typedef enum
+{
+    DDI_DETACH = 0,
+    DDI_SUSPEND = 1,
+    DDI_PM_SUSPEND = 2,
+    DDI_HOTPLUG_DETACH = 3
+} ddi_detach_cmd_t;
+
+/* Simple types */
+
+typedef struct cred *cred_t;
+typedef struct dev_info *dev_info_t;
+typedef struct __ddi_acc_handle * ddi_acc_handle_t;
+typedef struct __ddi_intr_handle *ddi_intr_handle_t;
+typedef struct mutex *kmutex_t;
+typedef unsigned int uint_t;
+typedef unsigned short ushort_t;
+typedef unsigned char uchar_t;
+
+/* Structures */
+
+struct modspecific_info {
+    char    msi_linkinfo[MODMAXLINKINFOLEN];
+    int     msi_p0;
+};
+
+struct modinfo {
+    int                mi_info;
+    int                mi_state;
+    int                mi_id;
+    int                mi_nextid;
+    char              *mi_base;  /* Was caddr_t. */
+    size_t             mi_size;
+    int                mi_rev;
+    int                mi_loadcnt;
+    char               mi_name[MODMAXNAMELEN];
+    struct modspecific_info mi_msinfo[MODMAXLINK];
+};
+
+typedef struct queue
+{
+    struct    qinit   *q_qinfo;
+    struct    msgb    *q_first;
+    struct    msgb    *q_last;
+    struct    queue   *q_next;
+    void              *q_ptr;
+    size_t             q_count;
+    uint_t             q_flag;
+    ssize_t            q_minpsz;
+    ssize_t            q_maxpsz;
+    size_t             q_hiwat;
+    size_t             q_lowat;
+} queue_t;
+
+typedef struct msgb
+{
+    struct msgb     *b_next;
+    struct msgb     *b_prev;
+    struct msgb     *b_cont;
+    unsigned char   *b_rptr;
+    unsigned char   *b_wptr;
+    struct datab    *b_datap;
+    unsigned char   b_band;
+    unsigned short  b_flag;
+} mblk_t;
+
+typedef struct datab
+{
+    unsigned char     *db_base;
+    unsigned char     *db_lim;
+    unsigned char      db_ref;
+    unsigned char      db_type;
+} dblk_t;
+
+struct iocblk
+{
+    int         ioc_cmd;
+    cred_t      *ioc_cr;
+    uint_t      ioc_id;
+    uint_t      ioc_flag;
+    size_t      ioc_count;
+    int         ioc_rval;
+    int         ioc_error;
+#if defined(RT_ARCH_AMD64)  /* Actually this should be LP64. */
+    int         dummy;  /* For simplicity, to ensure the structure size matches
+                           struct copyreq. */
+#endif
+};
+
+struct copyreq
+{
+    int       cq_cmd;
+    cred_t   *cq_cr;
+    uint_t    cq_id;
+    uint_t    cq_flag;
+    mblk_t   *cq_private;
+    char     *cq_addr;  /* Was caddr_t. */
+    size_t    cq_size;
+};
+
+struct copyresp
+{
+    int      cp_cmd;
+    cred_t   *cp_cr;
+    uint_t   cp_id;
+    uint_t   cp_flag;
+    mblk_t   *cp_private;
+    char     *cp_rval;  /* Was caddr_t. */
+};
+
+typedef struct modctl
+{
+    /* ... */
+    char mod_loadflags;
+    /* ... */
+} modctl_t;
+
+typedef struct {
+    int     jitter_thresh;
+    int     speed_law;
+    int     speed_limit;
+} Ms_parms;
+
+typedef struct {
+    int     height;
+    int     width;
+} Ms_screen_resolution;
+
+typedef struct  vuid_addr_probe {
+    short   base;
+    union
+    {
+        short   next;
+        short   current;
+    } data;
+} Vuid_addr_probe;
+
+typedef struct ddi_device_acc_attr
+{
+    ushort_t devacc_attr_version;
+    uchar_t devacc_attr_endian_flags;
+    uchar_t devacc_attr_dataorder;
+    uchar_t devacc_attr_access;
+} ddi_device_acc_attr_t;
+
+typedef struct firm_event
+{
+    ushort_t        id;
+    uchar_t         pair_type;
+    uchar_t         pair;
+    int             value;
+    struct timeval time;
+} Firm_event;
+
+/* Prototypes */
+
+#define _init vboxguestSolarisInit
+extern int vboxguestSolarisInit(void);
+#define _fini vboxguestSolarisFini
+extern int vboxguestSolarisFini(void);
+#define _info vboxguestSolarisInfo
+extern int vboxguestSolarisInfo(struct modinfo *pModInfo);
+
+/* Simple API stubs */
+
+#define cmn_err(...) do {} while(0)
+#define mod_remove(...) 0
+#define mod_info(...) 0
+#define RTR0Init(...) VINF_SUCCESS
+#define RTR0Term(...) do {} while(0)
+#define RTR0AssertPanicSystem(...) do {} while(0)
+#define RTLogCreate(...) VINF_SUCCESS
+#define RTLogRelSetDefaultInstance(...) do {} while(0)
+#define RTLogDestroy(...) do {} while(0)
+#if 0
+#define VBoxGuestCreateKernelSession(...) VINF_SUCCESS
+#define VBoxGuestCreateUserSession(...) VINF_SUCCESS
+#define VBoxGuestCloseSession(...) do {} while(0)
+#define VBoxGuestInitDevExt(...) VINF_SUCCESS
+#define VBoxGuestDeleteDevExt(...) do {} while(0)
+#define VBoxGuestCommonIOCtl(...) VINF_SUCCESS
+#define VBoxGuestCommonISR(...) true
+#define VbglR0GRAlloc(...) VINF_SUCCESS
+#define VbglR0GRPerform(...) VINF_SUCCESS
+#define VbglR0GRFree(...) do {} while(0)
+#endif
+#define VbglR0InitClient(...) VINF_SUCCESS
+#define vbglDriverOpen(...) VINF_SUCCESS
+#define vbglDriverClose(...) do {} while(0)
+#define vbglDriverIOCtl(...) VINF_SUCCESS
+#define qprocson(...) do {} while(0)
+#define qprocsoff(...) do {} while(0)
+#define flushq(...) do {} while(0)
+#define putnext(...) do {} while(0)
+#define ddi_get_instance(...) 0
+#define pci_config_setup(...) DDI_SUCCESS
+#define pci_config_teardown(...) do {} while(0)
+#define ddi_regs_map_setup(...) DDI_SUCCESS
+#define ddi_regs_map_free(...) do {} while(0)
+#define ddi_dev_regsize(...) DDI_SUCCESS
+#define ddi_create_minor_node(...) DDI_SUCCESS
+#define ddi_remove_minor_node(...) do {} while(0)
+#define ddi_intr_get_supported_types(...) DDI_SUCCESS
+#define ddi_intr_get_nintrs(...) DDI_SUCCESS
+#define ddi_intr_get_navail(...) DDI_SUCCESS
+#define ddi_intr_alloc(...) DDI_SUCCESS
+#define ddi_intr_free(...) do {} while(0)
+#define ddi_intr_get_pri(...) DDI_SUCCESS
+#define ddi_intr_enable(...) DDI_SUCCESS
+#define ddi_intr_disable(...) DDI_SUCCESS
+#define ddi_intr_add_handler(...) DDI_SUCCESS
+#define ddi_intr_remove_handler(...) DDI_SUCCESS
+#define mutex_init(...) do {} while(0)
+#define mutex_destroy(...) do {} while(0)
+#define mutex_enter(...) do {} while(0)
+#define mutex_exit(...) do {} while(0)
+#define uniqtime32(...) do {} while(0)
+#define canput(...) true
+#define putbq(...) do {} while(0)
+
+/* Externally defined helpers. */
+
+/** Flags set in the struct mblk b_flag member for verification purposes.
+ * @{ */
+/** miocpullup was called for this message. */
+#define F_TEST_PULLUP 1
+/** @} */
+
+extern void miocack(queue_t *pWriteQueue, mblk_t *pMBlk, int cbData, int rc);
+extern void miocnak(queue_t *pWriteQueue, mblk_t *pMBlk, int cbData, int iErr);
+extern int miocpullup(mblk_t *pMBlk, size_t cbMsg);
+extern void mcopyin(mblk_t *pMBlk, void *pvState, size_t cbData, void *pvUser);
+extern void mcopyout(mblk_t *pMBlk, void *pvState, size_t cbData, void *pvUser,
+                     mblk_t *pMBlkData);
+extern void qreply(queue_t *pQueue, mblk_t *pMBlk);
+extern mblk_t *allocb(size_t cb, uint_t cPrio);
+extern void freemsg(mblk_t *pMsg);
+
+/* API stubs with simple logic */
+
+static modctl_t s_ModCtl;
+static void **s_pvLinkage;
+
+static inline modctl_t *mod_getctl(void **linkage)
+{
+    s_pvLinkage = linkage;
+    return s_pvLinkage ? &s_ModCtl : NULL;
+}
+
+#define mod_install(linkage) (s_pvLinkage && ((linkage) == s_pvLinkage) ? 0 : EINVAL)
+#define QREADR          0x00000010
+#define         OTHERQ(q)      ((q)->q_flag & QREADR ? (q) + 1 : (q) - 1)
+#define         WR(q)          ((q)->q_flag & QREADR ? (q) + 1 : (q))
+#define         RD(q)          ((q)->q_flag & QREADR ? (q) : (q) - 1)
+
+
+/* Basic initialisation of a queue structure pair for testing. */
+static inline void doInitQueues(queue_t aQueues[2])
+{
+    aQueues[0].q_flag = QREADR;
+}
+
+static inline dev_t makedevice(unsigned cMajor, unsigned cMinor)
+{
+    return cMajor * 4096 + cMinor;
+}
+
+static inline unsigned getmajor(dev_t device)
+{
+    return device / 4096;
+}
+
+/* API stubs with controllable logic */
+
+#endif /* !GA_INCLUDED_SRC_solaris_Mouse_testcase_solaris_h */
diff --git a/src/VBox/Additions/solaris/Mouse/testcase/tstVBoxMouse-solaris.c b/src/VBox/Additions/solaris/Mouse/testcase/tstVBoxMouse-solaris.c
new file mode 100644
index 00000000..02d44093
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/testcase/tstVBoxMouse-solaris.c
@@ -0,0 +1,160 @@
+/** @file
+ * VirtualBox Guest Additions Driver for Solaris - Solaris helper functions.
+ */
+
+/*
+ * Copyright (C) 2012-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+
+#include "solaris.h"
+#include <iprt/alloc.h>
+
+
+/*********************************************************************************************************************************
+*   Helper functions                                                                                                             *
+*********************************************************************************************************************************/
+
+void miocack(queue_t *pWriteQueue, mblk_t *pMBlk, int cbData, int rc)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+
+    pMBlk->b_datap->db_type = M_IOCACK;
+    pIOCBlk->ioc_count = cbData;
+    pIOCBlk->ioc_rval = rc;
+    pIOCBlk->ioc_error = 0;
+    qreply(pWriteQueue, pMBlk);
+}
+
+void miocnak(queue_t *pWriteQueue, mblk_t *pMBlk, int cbData, int iErr)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+
+    pMBlk->b_datap->db_type = M_IOCNAK;
+    pIOCBlk->ioc_count = cbData;
+    pIOCBlk->ioc_error = iErr ? iErr : EINVAL;
+    pIOCBlk->ioc_rval = 0;
+    qreply(pWriteQueue, pMBlk);
+}
+
+/* This does not work like the real version, but does some sanity testing
+ * and sets a flag. */
+int miocpullup(mblk_t *pMBlk, size_t cbMsg)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+
+    if (pIOCBlk->ioc_count == TRANSPARENT)
+        return EINVAL;
+    if (   !pMBlk->b_cont
+        || pMBlk->b_cont->b_wptr < pMBlk->b_cont->b_rptr + cbMsg)
+        return EINVAL;
+    pMBlk->b_flag |= F_TEST_PULLUP;
+    return 0;
+}
+
+void mcopyin(mblk_t *pMBlk, void *pvState, size_t cbData, void *pvUser)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+    struct copyreq *pCopyReq = (struct copyreq *)pMBlk->b_rptr;
+
+    AssertReturnVoid(   pvUser
+                     || (   pMBlk->b_datap->db_type == M_IOCTL
+                         && pIOCBlk->ioc_count == TRANSPARENT
+                         && pMBlk->b_cont->b_rptr));
+    pMBlk->b_datap->db_type = M_COPYIN;
+    pMBlk->b_wptr = pMBlk->b_rptr + sizeof(*pCopyReq);
+    pCopyReq->cq_private = pvState;
+    pCopyReq->cq_size = cbData;
+    pCopyReq->cq_addr = pvUser ? pvUser : *(void **)pMBlk->b_cont->b_rptr;
+    if (pMBlk->b_cont)
+    {
+        freemsg(pMBlk->b_cont);
+        pMBlk->b_cont = NULL;
+    }
+}
+
+void mcopyout(mblk_t *pMBlk, void *pvState, size_t cbData, void *pvUser,
+              mblk_t *pMBlkData)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+    struct copyreq *pCopyReq = (struct copyreq *)pMBlk->b_rptr;
+
+    AssertReturnVoid(   pvUser
+                     || (   pMBlk->b_datap->db_type == M_IOCTL
+                         && pIOCBlk->ioc_count == TRANSPARENT
+                         && pMBlk->b_cont->b_rptr));
+    pMBlk->b_datap->db_type = M_COPYOUT;
+    pMBlk->b_wptr = pMBlk->b_rptr + sizeof(*pCopyReq);
+    pCopyReq->cq_private = pvState;
+    pCopyReq->cq_size = cbData;
+    pCopyReq->cq_addr = pvUser ? pvUser : *(void **)pMBlk->b_cont->b_rptr;
+    if (pMBlkData)
+    {
+        if (pMBlk->b_cont)
+            freemsg(pMBlk->b_cont);
+        pMBlk->b_cont = pMBlkData;
+        pMBlkData->b_wptr = pMBlkData->b_rptr + cbData;
+    }
+}
+
+/* This does not work like the real version but is easy to test the result of.
+ */
+void qreply(queue_t *pQueue, mblk_t *pMBlk)
+{
+    OTHERQ(pQueue)->q_first = pMBlk;
+}
+
+/** @todo reference counting */
+mblk_t *allocb(size_t cb, uint_t cPrio)
+{
+    unsigned char *pch = RTMemAllocZ(cb);
+    struct msgb *pMBlk = (struct msgb *)RTMemAllocZ(sizeof(struct msgb));
+    struct datab *pDBlk = (struct datab *)RTMemAllocZ(sizeof(struct datab));
+    if (!pch || !pMBlk || !pDBlk)
+    {
+        RTMemFree(pch);
+        RTMemFree(pMBlk);
+        RTMemFree(pDBlk);
+        return NULL;
+    }
+    NOREF(cPrio);
+    pMBlk->b_rptr = pch;
+    pMBlk->b_wptr = pMBlk->b_rptr + cb;
+    pMBlk->b_datap = pDBlk;
+    pDBlk->db_base = pMBlk->b_rptr;
+    pDBlk->db_lim = pMBlk->b_wptr;
+    pDBlk->db_type = M_DATA;
+    return pMBlk;
+}
+
+/** @todo reference counting */
+void freemsg(mblk_t *pMBlk)
+{
+    if (!pMBlk)
+        return;
+    RTMemFree(pMBlk->b_rptr);
+    RTMemFree(pMBlk->b_datap);
+    freemsg(pMBlk->b_cont);
+    RTMemFree(pMBlk);
+}
diff --git a/src/VBox/Additions/solaris/Mouse/vboxms.c b/src/VBox/Additions/solaris/Mouse/vboxms.c
new file mode 100644
index 00000000..e1256b52
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/vboxms.c
@@ -0,0 +1,1434 @@
+/* $Id: vboxms.c $ */
+/** @file
+ * VirtualBox Guest Additions Mouse Driver for Solaris.
+ */
+
+/*
+ * Copyright (C) 2012-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DRV_MOUSE
+#include <VBox/VMMDev.h>
+#include <VBox/VBoxGuestLib.h>
+#include <VBox/log.h>
+#include <VBox/version.h>
+#include <iprt/assert.h>
+#include <iprt/asm.h>
+
+#ifndef TESTCASE
+# include <sys/modctl.h>
+# include <sys/msio.h>
+# include <sys/stat.h>
+# include <sys/ddi.h>
+# include <sys/strsun.h>
+# include <sys/stropts.h>
+# include <sys/sunddi.h>
+# include <sys/vuid_event.h>
+# include <sys/vuid_wheel.h>
+#undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
+#else  /* TESTCASE */
+# undef IN_RING3
+# define IN_RING0
+#endif  /* TESTCASE */
+
+#ifdef TESTCASE  /* Include this last as we . */
+# include "testcase/solaris.h"
+# include <iprt/test.h>
+#endif  /* TESTCASE */
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+/** The module name. */
+#define DEVICE_NAME              "vboxms"
+/** The module description as seen in 'modinfo'. */
+#define DEVICE_DESC              "VBoxMouseIntegr"
+
+
+/*********************************************************************************************************************************
+*   Internal functions used in global structures                                                                                 *
+*********************************************************************************************************************************/
+
+static int vbmsSolAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd);
+static int vbmsSolDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
+static int vbmsSolGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg,
+                          void **ppvResult);
+static int vbmsSolOpen(queue_t *pReadQueue, dev_t *pDev, int fFlag,
+                                int fMode, cred_t *pCred);
+static int vbmsSolClose(queue_t *pReadQueue, int fFlag, cred_t *pCred);
+static int vbmsSolWPut(queue_t *pWriteQueue, mblk_t *pMBlk);
+
+
+/*********************************************************************************************************************************
+*   Driver global structures                                                                                                     *
+*********************************************************************************************************************************/
+
+#ifndef TESTCASE  /* I see no value in including these in the test. */
+
+/*
+ * mod_info: STREAMS module information.
+ */
+static struct module_info g_vbmsSolModInfo =
+{
+    0,                      /* module id number */
+    "vboxms",
+    0,                      /* minimum packet size */
+    INFPSZ,                 /* maximum packet size accepted */
+    512,                    /* high water mark for data flow control */
+    128                     /* low water mark */
+};
+
+/*
+ * rinit: read queue structure for handling messages coming from below.  In
+ * our case this means the host and the virtual hardware, so we do not need
+ * the put and service procedures.
+ */
+static struct qinit g_vbmsSolRInit =
+{
+    NULL,                /* put */
+    NULL,                /* service thread procedure */
+    vbmsSolOpen,
+    vbmsSolClose,
+    NULL,                /* reserved */
+    &g_vbmsSolModInfo,
+    NULL                 /* module statistics structure */
+};
+
+/*
+ * winit: write queue structure for handling messages coming from above.  Above
+ * means user space applications: either Guest Additions user space tools or
+ * applications reading pointer input.  Messages from the last most likely pass
+ * through at least the "consms" console mouse streams module which multiplexes
+ * hardware pointer drivers to a single virtual pointer.
+ */
+static struct qinit g_vbmsSolWInit =
+{
+    vbmsSolWPut,
+    NULL,                   /* service thread procedure */
+    NULL,                   /* open */
+    NULL,                   /* close */
+    NULL,                   /* reserved */
+    &g_vbmsSolModInfo,
+    NULL                    /* module statistics structure */
+};
+
+/**
+ * streamtab: for drivers that support char/block entry points.
+ */
+static struct streamtab g_vbmsSolStreamTab =
+{
+    &g_vbmsSolRInit,
+    &g_vbmsSolWInit,
+    NULL,                   /* MUX rinit */
+    NULL                    /* MUX winit */
+};
+
+/**
+ * cb_ops: for drivers that support char/block entry points
+ */
+static struct cb_ops g_vbmsSolCbOps =
+{
+    nodev,                  /* open */
+    nodev,                  /* close */
+    nodev,                  /* b strategy */
+    nodev,                  /* b dump */
+    nodev,                  /* b print */
+    nodev,                  /* c read */
+    nodev,                  /* c write */
+    nodev,                  /* c ioctl */
+    nodev,                  /* c devmap */
+    nodev,                  /* c mmap */
+    nodev,                  /* c segmap */
+    nochpoll,               /* c poll */
+    ddi_prop_op,            /* property ops */
+    &g_vbmsSolStreamTab,
+    D_MP,
+    CB_REV                  /* revision */
+};
+
+/**
+ * dev_ops: for driver device operations
+ */
+static struct dev_ops g_vbmsSolDevOps =
+{
+    DEVO_REV,               /* driver build revision */
+    0,                      /* ref count */
+    vbmsSolGetInfo,
+    nulldev,                /* identify */
+    nulldev,                /* probe */
+    vbmsSolAttach,
+    vbmsSolDetach,
+    nodev,                  /* reset */
+    &g_vbmsSolCbOps,
+    NULL,                   /* bus operations */
+    nodev                   /* power */
+};
+
+/**
+ * modldrv: export driver specifics to the kernel
+ */
+static struct modldrv g_vbmsSolModule =
+{
+    &mod_driverops,         /* extern from kernel */
+    DEVICE_DESC " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV),
+    &g_vbmsSolDevOps
+};
+
+/**
+ * modlinkage: export install/remove/info to the kernel.
+ */
+static struct modlinkage g_vbmsSolModLinkage =
+{
+    MODREV_1,               /* loadable module system revision */
+    &g_vbmsSolModule,
+    NULL                    /* terminate array of linkage structures */
+};
+
+#else  /* TESTCASE */
+static void *g_vbmsSolModLinkage;
+#endif  /* TESTCASE */
+
+/**
+ * State info for each open file handle.
+ */
+typedef struct
+{
+    /** Device handle. */
+    dev_info_t           *pDip;
+    /** Mutex protecting the guest library against multiple initialistation or
+     * uninitialisation. */
+    kmutex_t              InitMtx;
+    /** Initialisation counter for the guest library. */
+    size_t                cInits;
+    /** The STREAMS write queue which we need for sending messages up to
+     * user-space. */
+    queue_t              *pWriteQueue;
+    /** Pre-allocated mouse status VMMDev request for use in the IRQ
+     * handler. */
+    VMMDevReqMouseStatus *pMouseStatusReq;
+    /* The current greatest horizontal pixel offset on the screen, used for
+     * absolute mouse position reporting.
+     */
+    int                   cMaxScreenX;
+    /* The current greatest vertical pixel offset on the screen, used for
+     * absolute mouse position reporting.
+     */
+    int                   cMaxScreenY;
+} VBMSSTATE, *PVBMSSTATE;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+
+/** Global driver state.  Actually this could be allocated dynamically. */
+static VBMSSTATE            g_OpenNodeState /* = { 0 } */;
+
+
+/*********************************************************************************************************************************
+*   Kernel entry points                                                                                                          *
+*********************************************************************************************************************************/
+
+/** Driver initialisation. */
+int _init(void)
+{
+    int rc;
+    LogRelFlow((DEVICE_NAME ": built on " __DATE__ " at " __TIME__ "\n"));
+    mutex_init(&g_OpenNodeState.InitMtx, NULL, MUTEX_DRIVER, NULL);
+    /*
+     * Prevent module autounloading.
+     */
+    modctl_t *pModCtl = mod_getctl(&g_vbmsSolModLinkage);
+    if (pModCtl)
+        pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
+    else
+        LogRel((DEVICE_NAME ": failed to disable autounloading!\n"));
+    rc = mod_install(&g_vbmsSolModLinkage);
+
+    LogRelFlow((DEVICE_NAME ": initialisation returning %d.\n", rc));
+    return rc;
+}
+
+
+#ifdef TESTCASE
+/** Simple test of the flow through _init. */
+static void test_init(RTTEST hTest)
+{
+    RTTestSub(hTest, "Testing _init");
+    RTTEST_CHECK(hTest, _init() == 0);
+}
+#endif
+
+
+/** Driver cleanup. */
+int _fini(void)
+{
+    int rc;
+
+    LogRelFlow((DEVICE_NAME ":_fini\n"));
+    rc = mod_remove(&g_vbmsSolModLinkage);
+    if (!rc)
+        mutex_destroy(&g_OpenNodeState.InitMtx);
+
+    return rc;
+}
+
+
+/** Driver identification. */
+int _info(struct modinfo *pModInfo)
+{
+    int rc;
+    LogRelFlow((DEVICE_NAME ":_info\n"));
+    rc = mod_info(&g_vbmsSolModLinkage, pModInfo);
+    LogRelFlow((DEVICE_NAME ":_info returning %d\n", rc));
+    return rc;
+}
+
+
+/*********************************************************************************************************************************
+*   Initialisation entry points                                                                                                  *
+*********************************************************************************************************************************/
+
+/**
+ * Attach entry point, to attach a device to the system or resume it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   enmCmd          Attach type (ddi_attach_cmd_t)
+ *
+ * @return  corresponding solaris error code.
+ */
+int vbmsSolAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
+{
+    LogRelFlow((DEVICE_NAME "::Attach\n"));
+    switch (enmCmd)
+    {
+        case DDI_ATTACH:
+        {
+            int rc;
+            int instance = ddi_get_instance(pDip);
+            /* Only one instance supported. */
+            if (!ASMAtomicCmpXchgPtr(&g_OpenNodeState.pDip, pDip, NULL))
+                return DDI_FAILURE;
+            rc = ddi_create_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO, 0);
+            if (rc == DDI_SUCCESS)
+                return DDI_SUCCESS;
+            ASMAtomicWritePtr(&g_OpenNodeState.pDip, NULL);
+            return DDI_FAILURE;
+        }
+
+        case DDI_RESUME:
+        {
+            /** @todo implement resume for guest driver. */
+            return DDI_SUCCESS;
+        }
+
+        default:
+            return DDI_FAILURE;
+    }
+}
+
+
+/**
+ * Detach entry point, to detach a device to the system or suspend it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   enmCmd          Attach type (ddi_attach_cmd_t)
+ *
+ * @return  corresponding solaris error code.
+ */
+int vbmsSolDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
+{
+    LogRelFlow((DEVICE_NAME "::Detach\n"));
+    switch (enmCmd)
+    {
+        case DDI_DETACH:
+        {
+            ddi_remove_minor_node(pDip, NULL);
+            ASMAtomicWritePtr(&g_OpenNodeState.pDip, NULL);
+            return DDI_SUCCESS;
+        }
+
+        case DDI_SUSPEND:
+        {
+            /** @todo implement suspend for guest driver. */
+            return DDI_SUCCESS;
+        }
+
+        default:
+            return DDI_FAILURE;
+    }
+}
+
+
+/**
+ * Info entry point, called by solaris kernel for obtaining driver info.
+ *
+ * @param   pDip            The module structure instance (do not use).
+ * @param   enmCmd          Information request type.
+ * @param   pvArg           Type specific argument.
+ * @param   ppvResult       Where to store the requested info.
+ *
+ * @return  corresponding solaris error code.
+ */
+int vbmsSolGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg,
+                   void **ppvResult)
+{
+    LogRelFlow((DEVICE_NAME "::GetInfo\n"));
+
+    int rc = DDI_SUCCESS;
+    switch (enmCmd)
+    {
+        case DDI_INFO_DEVT2DEVINFO:
+            *ppvResult = (void *)g_OpenNodeState.pDip;
+            break;
+
+        case DDI_INFO_DEVT2INSTANCE:
+            *ppvResult = (void *)(uintptr_t)ddi_get_instance(g_OpenNodeState.pDip);
+            break;
+
+        default:
+            rc = DDI_FAILURE;
+            break;
+    }
+
+    NOREF(pvArg);
+    return rc;
+}
+
+
+/*********************************************************************************************************************************
+*   Main code                                                                                                                    *
+*********************************************************************************************************************************/
+
+static void vbmsSolNotify(void *pvState);
+static void vbmsSolVUIDPutAbsEvent(PVBMSSTATE pState, ushort_t cEvent,
+                                   int cValue);
+
+/**
+ * Open callback for the read queue, which we use as a generic device open
+ * handler.
+ */
+int vbmsSolOpen(queue_t *pReadQueue, dev_t *pDev, int fFlag, int fMode,
+                 cred_t *pCred)
+{
+    PVBMSSTATE pState = NULL;
+    int rc = VINF_SUCCESS;
+
+    NOREF(fFlag);
+    NOREF(pCred);
+    LogRelFlow((DEVICE_NAME "::Open, pWriteQueue=%p\n", WR(pReadQueue)));
+
+    /*
+     * Sanity check on the mode parameter - only open as a driver, not a
+     * module, and we do cloning ourselves.
+     */
+    if (fMode)
+    {
+        LogRel(("::Open: invalid attempt to clone device."));
+        return EINVAL;
+    }
+
+    pState = &g_OpenNodeState;
+    mutex_enter(&pState->InitMtx);
+    /*
+     * Check and remember our STREAM queue.
+     */
+    if (   pState->pWriteQueue
+        && (pState->pWriteQueue != WR(pReadQueue)))
+    {
+        mutex_exit(&pState->InitMtx);
+        LogRel((DEVICE_NAME "::Open: unexpectedly called with a different queue to previous calls.  Exiting.\n"));
+        return EINVAL;
+    }
+    if (!pState->cInits)
+    {
+        /*
+         * Initialize IPRT R0 driver, which internally calls OS-specific r0
+         * init, and create a new session.
+         */
+        rc = VbglR0InitClient();
+        if (RT_SUCCESS(rc))
+        {
+            rc = VbglR0GRAlloc((VMMDevRequestHeader **)
+                             &pState->pMouseStatusReq,
+                             sizeof(*pState->pMouseStatusReq),
+                             VMMDevReq_GetMouseStatus);
+            if (RT_FAILURE(rc))
+                VbglR0TerminateClient();
+            else
+            {
+                int rc2;
+                /* Initialise user data for the queues to our state and
+                 * vice-versa. */
+                pState->pWriteQueue = WR(pReadQueue);
+                WR(pReadQueue)->q_ptr = (char *)pState;
+                pReadQueue->q_ptr = (char *)pState;
+                qprocson(pReadQueue);
+                /* Enable our IRQ handler. */
+                rc2 = VbglR0SetMouseNotifyCallback(vbmsSolNotify, (void *)pState);
+                if (RT_FAILURE(rc2))
+                    /* Log the failure.  I may well have not understood what
+                     * is going on here, and the logging may help me. */
+                    LogRelFlow(("Failed to install the event handler call-back, rc=%Rrc\n",
+                                rc2));
+            }
+        }
+    }
+    if (RT_SUCCESS(rc))
+        ++pState->cInits;
+    mutex_exit(&pState->InitMtx);
+    if (RT_FAILURE(rc))
+    {
+        LogRel(("open time initialisation failed. rc=%d\n", rc));
+        ASMAtomicWriteNullPtr(&pState->pWriteQueue);
+        return EINVAL;
+    }
+    return 0;
+}
+
+
+/**
+ * Notification callback, called when the VBoxGuest mouse pointer is moved.
+ * We send a VUID event up to user space.  We may send a miscalculated event
+ * if a resolution change is half-way through, but that is pretty much to be
+ * expected, so we won't worry about it.
+ */
+void vbmsSolNotify(void *pvState)
+{
+    PVBMSSTATE pState = (PVBMSSTATE)pvState;
+    int rc;
+
+    pState->pMouseStatusReq->mouseFeatures = 0;
+    pState->pMouseStatusReq->pointerXPos = 0;
+    pState->pMouseStatusReq->pointerYPos = 0;
+    rc = VbglR0GRPerform(&pState->pMouseStatusReq->header);
+    if (RT_SUCCESS(rc))
+    {
+        int cMaxScreenX  = pState->cMaxScreenX;
+        int cMaxScreenY  = pState->cMaxScreenY;
+        int x = pState->pMouseStatusReq->pointerXPos;
+        int y = pState->pMouseStatusReq->pointerYPos;
+
+        if (cMaxScreenX && cMaxScreenY)
+        {
+            vbmsSolVUIDPutAbsEvent(pState, LOC_X_ABSOLUTE,
+                                   x * cMaxScreenX / VMMDEV_MOUSE_RANGE_MAX);
+            vbmsSolVUIDPutAbsEvent(pState, LOC_Y_ABSOLUTE,
+                                   y * cMaxScreenY / VMMDEV_MOUSE_RANGE_MAX);
+        }
+    }
+}
+
+
+void vbmsSolVUIDPutAbsEvent(PVBMSSTATE pState, ushort_t cEvent,
+                            int cValue)
+{
+    queue_t *pReadQueue = RD(pState->pWriteQueue);
+    mblk_t *pMBlk = allocb(sizeof(Firm_event), BPRI_HI);
+    Firm_event *pEvent;
+    AssertReturnVoid(cEvent == LOC_X_ABSOLUTE || cEvent == LOC_Y_ABSOLUTE);
+    if (!pMBlk)
+        return;  /* If kernel memory is short a missed event is acceptable! */
+    pEvent = (Firm_event *)pMBlk->b_wptr;
+    pEvent->id        = cEvent;
+    pEvent->pair_type = FE_PAIR_DELTA;
+    pEvent->pair      = cEvent == LOC_X_ABSOLUTE ? LOC_X_DELTA : LOC_Y_DELTA;
+    pEvent->value     = cValue;
+    uniqtime32(&pEvent->time);
+    pMBlk->b_wptr += sizeof(Firm_event);
+    /* Put the message on the queue immediately if it is not blocked. */
+    if (canput(pReadQueue->q_next))
+        putnext(pReadQueue, pMBlk);
+    else
+        putq(pReadQueue, pMBlk);
+}
+
+
+/**
+ * Close callback for the read queue, which we use as a generic device close
+ * handler.
+ */
+int vbmsSolClose(queue_t *pReadQueue, int fFlag, cred_t *pCred)
+{
+    PVBMSSTATE pState = (PVBMSSTATE)pReadQueue->q_ptr;
+
+    LogRelFlow((DEVICE_NAME "::Close, pWriteQueue=%p\n", WR(pReadQueue)));
+    NOREF(fFlag);
+    NOREF(pCred);
+
+    if (!pState)
+    {
+        Log((DEVICE_NAME "::Close: failed to get pState.\n"));
+        return EFAULT;
+    }
+
+    mutex_enter(&pState->InitMtx);
+    --pState->cInits;
+    if (!pState->cInits)
+    {
+        VbglR0SetMouseStatus(0);
+        /* Disable our IRQ handler. */
+        VbglR0SetMouseNotifyCallback(NULL, NULL);
+        qprocsoff(pReadQueue);
+
+        /*
+         * Close the session.
+         */
+        ASMAtomicWriteNullPtr(&pState->pWriteQueue);
+        pReadQueue->q_ptr = NULL;
+        VbglR0GRFree(&pState->pMouseStatusReq->header);
+        VbglR0TerminateClient();
+    }
+    mutex_exit(&pState->InitMtx);
+    return 0;
+}
+
+
+#ifdef TESTCASE
+/** Simple test of vbmsSolOpen and vbmsSolClose. */
+static void testOpenClose(RTTEST hTest)
+{
+    queue_t aQueues[2];
+    dev_t device = 0;
+    int rc;
+
+    RTTestSub(hTest, "Testing vbmsSolOpen and vbmsSolClose");
+    RT_ZERO(g_OpenNodeState);
+    RT_ZERO(aQueues);
+    doInitQueues(&aQueues[0]);
+    rc = vbmsSolOpen(RD(&aQueues[0]), &device, 0, 0, NULL);
+    RTTEST_CHECK(hTest, rc == 0);
+    RTTEST_CHECK(hTest, g_OpenNodeState.pWriteQueue == WR(&aQueues[0]));
+    vbmsSolClose(RD(&aQueues[0]), 0, NULL);
+}
+#endif
+
+
+/* Helper for vbmsSolWPut. */
+static int vbmsSolDispatchIOCtl(PVBMSSTATE pState, mblk_t *pMBlk);
+
+/**
+ * Handler for messages sent from above (user-space and upper modules) which
+ * land in our write queue.
+ */
+int vbmsSolWPut(queue_t *pWriteQueue, mblk_t *pMBlk)
+{
+    PVBMSSTATE pState = (PVBMSSTATE)pWriteQueue->q_ptr;
+    LogRelFlowFunc((DEVICE_NAME "::"));
+    switch (pMBlk->b_datap->db_type)
+    {
+        case M_FLUSH:
+            LogRelFlow(("M_FLUSH, FLUSHW=%RTbool, FLUSHR=%RTbool\n",
+                        *pMBlk->b_rptr & FLUSHW, *pMBlk->b_rptr & FLUSHR));
+            /* Flush the write queue if so requested. */
+            if (*pMBlk->b_rptr & FLUSHW)
+                flushq(pWriteQueue, FLUSHDATA);
+
+            /* Flush the read queue if so requested. */
+            if (*pMBlk->b_rptr & FLUSHR)
+                flushq(RD(pWriteQueue), FLUSHDATA);
+
+            /* We have no one below us to pass the message on to. */
+            freemsg(pMBlk);
+            return 0;
+        /* M_IOCDATA is additional data attached to (at least) transparent
+         * IOCtls.  We handle the two together here and separate them further
+         * down. */
+        case M_IOCTL:
+        case M_IOCDATA:
+        {
+            int err;
+
+            LogRelFlow((  pMBlk->b_datap->db_type == M_IOCTL
+                        ? "M_IOCTL\n" : "M_IOCDATA\n"));
+            err = vbmsSolDispatchIOCtl(pState, pMBlk);
+            if (!err)
+                qreply(pWriteQueue, pMBlk);
+            else
+                miocnak(pWriteQueue, pMBlk, 0, err);
+            break;
+        }
+        default:
+            LogRelFlow(("Unknown command, not acknowledging.\n"));
+    }
+    return 0;
+}
+
+
+#ifdef TESTCASE
+/* Constants, definitions and test functions for testWPut. */
+static const int g_ccTestWPutFirmEvent = VUID_FIRM_EVENT;
+# define PVGFORMAT (&g_ccTestWPutFirmEvent)
+# define CBGFORMAT (sizeof(g_ccTestWPutFirmEvent))
+static const Ms_screen_resolution g_TestResolution = { 640, 480 };
+# define PMSIOSRES (&g_TestResolution)
+# define CBMSIOSRES (sizeof(g_TestResolution))
+
+static inline bool testSetResolution(RTTEST hTest, queue_t *pWriteQueue,
+                                     struct msgb *pMBlk)
+{
+    PVBMSSTATE pState = (PVBMSSTATE)pWriteQueue->q_ptr;
+    RTTEST_CHECK_MSG_RET(hTest,    pState->cMaxScreenX
+                               == g_TestResolution.width - 1,
+                         (hTest, "pState->cMaxScreenX=%d\n",
+                          pState->cMaxScreenX), false);
+    RTTEST_CHECK_MSG_RET(hTest,    pState->cMaxScreenY
+                               == g_TestResolution.height - 1,
+                         (hTest, "pState->cMaxScreenY=%d\n",
+                          pState->cMaxScreenY), false);
+    return true;
+}
+
+/** Data table for testWPut. */
+static struct
+{
+    int iIOCCmd;
+    size_t cbData;
+    const void *pvDataIn;
+    size_t cbDataIn;
+    const void *pvDataOut;
+    size_t cbDataOut;
+    int rcExp;
+    bool (*pfnExtra)(RTTEST hTest, queue_t *pWriteQueue, struct msgb *pMBlk);
+    bool fCanTransparent;
+} g_asTestWPut[] =
+{
+   /* iIOCCmd          cbData           pvDataIn   cbDataIn
+      pvDataOut   cbDataOut rcExp   pfnExtra           fCanTransparent */
+    { VUIDGFORMAT,     sizeof(int),     NULL,      0,
+      PVGFORMAT, CBGFORMAT, 0,      NULL,              true },
+    { VUIDGFORMAT,     sizeof(int) - 1, NULL,      0,
+      NULL,       0,        EINVAL, NULL,              false },
+    { VUIDGFORMAT,     sizeof(int) + 1, NULL,      0,
+      PVGFORMAT, CBGFORMAT, 0,      NULL,              true },
+    { VUIDSFORMAT,     sizeof(int),     PVGFORMAT, CBGFORMAT,
+      NULL,       0,        0,      NULL,              true },
+    { MSIOSRESOLUTION, CBMSIOSRES,      PMSIOSRES, CBMSIOSRES,
+      NULL,       0,        0,      testSetResolution, true },
+    { VUIDGWHEELINFO,  0,               NULL,      0,
+      NULL,       0,        EINVAL, NULL,              true }
+};
+
+# undef PVGFORMAT
+# undef CBGFORMAT
+# undef PMSIOSRES
+# undef CBMSIOSRES
+
+/* Helpers for testWPut. */
+static void testWPutStreams(RTTEST hTest, unsigned i);
+static void testWPutTransparent(RTTEST hTest, unsigned i);
+static void testWPutIOCDataIn(RTTEST hTest, unsigned i);
+static void testWPutIOCDataOut(RTTEST hTest, unsigned i);
+
+/** Test WPut's handling of different IOCtls, which is bulk of the logic in
+ * this file. */
+static void testWPut(RTTEST hTest)
+{
+    unsigned i;
+
+    RTTestSub(hTest, "Testing vbmsWPut");
+    for (i = 0; i < RT_ELEMENTS(g_asTestWPut); ++i)
+    {
+        AssertReturnVoid(g_asTestWPut[i].cbDataIn <= g_asTestWPut[i].cbData);
+        AssertReturnVoid(g_asTestWPut[i].cbDataOut <= g_asTestWPut[i].cbData);
+        testWPutStreams(hTest, i);
+        if (g_asTestWPut[i].fCanTransparent)
+            testWPutTransparent(hTest, i);
+        if (g_asTestWPut[i].fCanTransparent && g_asTestWPut[i].cbDataIn)
+            testWPutIOCDataIn(hTest, i);
+        if (g_asTestWPut[i].fCanTransparent && g_asTestWPut[i].cbDataOut)
+            testWPutIOCDataOut(hTest, i);
+    }
+}
+
+
+#define MSG_DATA_SIZE 1024
+
+/** Simulate sending a streams IOCtl to WPut with the parameters from table
+ * line @a i. */
+void testWPutStreams(RTTEST hTest, unsigned i)
+{
+    queue_t aQueues[2];
+    dev_t device = 0;
+    struct msgb *pMBlk = allocb(sizeof(struct iocblk), BPRI_MED);
+    struct msgb *pMBlkCont = allocb(MSG_DATA_SIZE, BPRI_MED);
+    struct iocblk *pIOCBlk = pMBlk ? (struct iocblk *)pMBlk->b_rptr : NULL;
+    int rc, cFormat = 0;
+
+    AssertReturnVoid(pMBlk);
+    AssertReturnVoidStmt(pMBlkCont, freemsg(pMBlk));
+    RT_ZERO(aQueues);
+    doInitQueues(&aQueues[0]);
+    rc = vbmsSolOpen(RD(&aQueues[0]), &device, 0, 0, NULL);
+    RTTEST_CHECK_MSG(hTest, rc == 0, (hTest, "i=%u, rc=%d\n", i, rc));
+    RTTEST_CHECK_MSG(hTest,    g_OpenNodeState.pWriteQueue
+                            == WR(&aQueues[0]), (hTest, "i=%u\n", i));
+    pMBlk->b_datap->db_type = M_IOCTL;
+    pIOCBlk->ioc_cmd = g_asTestWPut[i].iIOCCmd;
+    pIOCBlk->ioc_count = g_asTestWPut[i].cbData;
+    AssertReturnVoid(g_asTestWPut[i].cbData <= MSG_DATA_SIZE);
+    memcpy(pMBlkCont->b_rptr, g_asTestWPut[i].pvDataIn,
+           g_asTestWPut[i].cbDataIn);
+    pMBlk->b_cont = pMBlkCont;
+    rc = vbmsSolWPut(WR(&aQueues[0]), pMBlk);
+    RTTEST_CHECK_MSG(hTest, pIOCBlk->ioc_error == g_asTestWPut[i].rcExp,
+                     (hTest, "i=%u, IOCBlk.ioc_error=%d\n", i,
+                      pIOCBlk->ioc_error));
+    RTTEST_CHECK_MSG(hTest, pIOCBlk->ioc_count == g_asTestWPut[i].cbDataOut,
+                     (hTest, "i=%u, ioc_count=%u\n", i, pIOCBlk->ioc_count));
+    RTTEST_CHECK_MSG(hTest, !memcmp(pMBlkCont->b_rptr,
+                                    g_asTestWPut[i].pvDataOut,
+                                    g_asTestWPut[i].cbDataOut),
+                     (hTest, "i=%u\n", i));
+    /* Hack to ensure that miocpullup() gets called when needed. */
+    if (g_asTestWPut[i].cbData > 0)
+        RTTEST_CHECK_MSG(hTest, pMBlk->b_flag == 1, (hTest, "i=%u\n", i));
+    if (!g_asTestWPut[i].rcExp)
+        RTTEST_CHECK_MSG(hTest, RD(&aQueues[0])->q_first == pMBlk,
+                         (hTest, "i=%u\n", i));
+    if (g_asTestWPut[i].pfnExtra)
+        if (!g_asTestWPut[i].pfnExtra(hTest, WR(&aQueues[0]), pMBlk))
+            RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Called from %s.\n",
+                         __PRETTY_FUNCTION__);
+    vbmsSolClose(RD(&aQueues[1]), 0, NULL);
+    freemsg(pMBlk);
+}
+
+
+#define USER_ADDRESS 0xfeedbacc
+
+/** Simulate sending a transparent IOCtl to WPut with the parameters from table
+ * line @a i. */
+void testWPutTransparent(RTTEST hTest, unsigned i)
+{
+    queue_t aQueues[2];
+    dev_t device = 0;
+    struct msgb *pMBlk = allocb(sizeof(struct iocblk), BPRI_MED);
+    struct msgb *pMBlkCont = allocb(sizeof(void *), BPRI_MED);
+    struct iocblk *pIOCBlk = pMBlk ? (struct iocblk *)pMBlk->b_rptr : NULL;
+    struct copyreq *pCopyReq;
+    int rc, cFormat = 0;
+
+    /* if (g_asTestWPut[i].cbDataIn == 0 && g_asTestWPut[i].cbDataOut != 0)
+        return; */  /* This case will be handled once the current ones work. */
+    AssertReturnVoid(pMBlk);
+    AssertReturnVoidStmt(pMBlkCont, freemsg(pMBlk));
+    RT_ZERO(aQueues);
+    doInitQueues(&aQueues[0]);
+    rc = vbmsSolOpen(RD(&aQueues[0]), &device, 0, 0, NULL);
+    RTTEST_CHECK_MSG(hTest, rc == 0, (hTest, "i=%u, rc=%d\n", i, rc));
+    RTTEST_CHECK_MSG(hTest,    g_OpenNodeState.pWriteQueue
+                            == WR(&aQueues[0]), (hTest, "i=%u\n", i));
+    pMBlk->b_datap->db_type = M_IOCTL;
+    pIOCBlk->ioc_cmd = g_asTestWPut[i].iIOCCmd;
+    pIOCBlk->ioc_count = TRANSPARENT;
+    *(void **)pMBlkCont->b_rptr = (void *)USER_ADDRESS;
+    pMBlk->b_cont = pMBlkCont;
+    rc = vbmsSolWPut(WR(&aQueues[0]), pMBlk);
+    pCopyReq = (struct copyreq *)pMBlk->b_rptr;
+    RTTEST_CHECK_MSG(hTest, (   (   g_asTestWPut[i].cbDataIn
+                                 && (pMBlk->b_datap->db_type == M_COPYIN))
+                             || (   g_asTestWPut[i].cbDataOut
+                                 && (pMBlk->b_datap->db_type == M_COPYOUT))
+                             || (   (g_asTestWPut[i].rcExp == 0)
+                                 && pMBlk->b_datap->db_type == M_IOCACK)
+                             || (pMBlk->b_datap->db_type == M_IOCNAK)),
+                     (hTest, "i=%u, db_type=%u\n", i,
+                      (unsigned) pMBlk->b_datap->db_type));
+    /* Our TRANSPARENT IOCtls can only return non-zero if they have no payload.
+     * Others should either return zero or be non-TRANSPARENT only. */
+    if (pMBlk->b_datap->db_type == M_IOCNAK)
+        RTTEST_CHECK_MSG(hTest, pIOCBlk->ioc_error == g_asTestWPut[i].rcExp,
+                         (hTest, "i=%u, IOCBlk.ioc_error=%d\n", i,
+                          pIOCBlk->ioc_error));
+    if (g_asTestWPut[i].cbData)
+    {
+        RTTEST_CHECK_MSG(hTest, pCopyReq->cq_addr == (char *)USER_ADDRESS,
+                         (hTest, "i=%u, cq_addr=%p\n", i, pCopyReq->cq_addr));
+        RTTEST_CHECK_MSG(   hTest, pCopyReq->cq_size
+                         ==   g_asTestWPut[i].cbDataIn
+                            ? g_asTestWPut[i].cbDataIn
+                            : g_asTestWPut[i].cbDataOut,
+                         (hTest, "i=%u, cq_size=%llu\n", i,
+                          (unsigned long long)pCopyReq->cq_size));
+    }
+    /* Implementation detail - check that the private pointer is correctly
+     * set to the user address *for two direction IOCtls* or NULL otherwise. */
+    if (g_asTestWPut[i].cbDataIn && g_asTestWPut[i].cbDataOut)
+        RTTEST_CHECK_MSG(hTest, pCopyReq->cq_private == (mblk_t *)USER_ADDRESS,
+                         (hTest, "i=%u, cq_private=%p\n", i,
+                          pCopyReq->cq_private));
+    else if (   (pMBlk->b_datap->db_type == M_COPYIN)
+             || (pMBlk->b_datap->db_type == M_COPYOUT))
+        RTTEST_CHECK_MSG(hTest, !pCopyReq->cq_private,
+                         (hTest, "i=%u, cq_private=%p\n", i,
+                          pCopyReq->cq_private));
+    if (!g_asTestWPut[i].rcExp)
+        RTTEST_CHECK_MSG(hTest, RD(&aQueues[0])->q_first == pMBlk,
+                         (hTest, "i=%u\n", i));
+    if (g_asTestWPut[i].pfnExtra && !g_asTestWPut[i].cbData)
+        if (!g_asTestWPut[i].pfnExtra(hTest, WR(&aQueues[0]), pMBlk))
+            RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Called from %s.\n",
+                         __PRETTY_FUNCTION__);
+    vbmsSolClose(RD(&aQueues[1]), 0, NULL);
+    freemsg(pMBlk);
+}
+
+
+/** Simulate sending follow-on IOCData messages to a transparent IOCtl to WPut
+ * with the parameters from table line @a i. */
+void testWPutIOCDataIn(RTTEST hTest, unsigned i)
+{
+    queue_t aQueues[2];
+    dev_t device = 0;
+    struct msgb *pMBlk = allocb(sizeof(struct copyresp), BPRI_MED);
+    struct msgb *pMBlkCont = allocb(MSG_DATA_SIZE, BPRI_MED);
+    struct copyresp *pCopyResp = pMBlk ? (struct copyresp *)pMBlk->b_rptr
+                                       : NULL;
+    void *pvData = pMBlkCont ? pMBlkCont->b_rptr : NULL;
+    struct copyreq *pCopyReq;
+    int rc, cFormat = 0;
+
+    AssertReturnVoid(pMBlk);
+    AssertReturnVoidStmt(pMBlkCont, freemsg(pMBlk));
+    RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%s: i=%u\n", __PRETTY_FUNCTION__,
+                 i);
+    AssertReturnVoidStmt(g_asTestWPut[i].cbDataIn, freemsg(pMBlk));
+    RT_ZERO(aQueues);
+    doInitQueues(&aQueues[0]);
+    rc = vbmsSolOpen(RD(&aQueues[0]), &device, 0, 0, NULL);
+    RTTEST_CHECK_MSG(hTest, rc == 0, (hTest, "i=%u, rc=%d\n", i, rc));
+    RTTEST_CHECK_MSG(hTest,    g_OpenNodeState.pWriteQueue
+                            == WR(&aQueues[0]), (hTest, "i=%u\n", i));
+    pMBlk->b_datap->db_type = M_IOCDATA;
+    pCopyResp->cp_cmd = g_asTestWPut[i].iIOCCmd;
+    if (g_asTestWPut[i].cbDataOut)
+        pCopyResp->cp_private = USER_ADDRESS;
+    AssertReturnVoid(g_asTestWPut[i].cbData <= MSG_DATA_SIZE);
+    memcpy(pMBlkCont->b_rptr, g_asTestWPut[i].pvDataIn, g_asTestWPut[i].cbDataIn);
+    pMBlk->b_cont = pMBlkCont;
+    rc = vbmsSolWPut(WR(&aQueues[0]), pMBlk);
+    pCopyReq = (struct copyreq *)pMBlk->b_rptr;
+    RTTEST_CHECK_MSG(hTest, (   (   g_asTestWPut[i].cbDataOut
+                                 && (pMBlk->b_datap->db_type == M_COPYOUT))
+                             || (   (g_asTestWPut[i].rcExp == 0)
+                                 && pMBlk->b_datap->db_type == M_IOCACK)
+                             || (pMBlk->b_datap->db_type == M_IOCNAK)),
+                     (hTest, "i=%u, db_type=%u\n", i,
+                      (unsigned) pMBlk->b_datap->db_type));
+    if (g_asTestWPut[i].cbDataOut)
+    {
+        RTTEST_CHECK_MSG(hTest, pCopyReq->cq_addr == (char *)pvData,
+                         (hTest, "i=%u, cq_addr=%p\n", i, pCopyReq->cq_addr));
+        RTTEST_CHECK_MSG(hTest, pCopyReq->cq_size == g_asTestWPut[i].cbData,
+                         (hTest, "i=%u, cq_size=%llu\n", i,
+                          (unsigned long long)pCopyReq->cq_size));
+        RTTEST_CHECK_MSG(hTest, !memcmp(pvData, g_asTestWPut[i].pvDataOut,
+                                        g_asTestWPut[i].cbDataOut),
+                         (hTest, "i=%u\n", i));
+    }
+    RTTEST_CHECK_MSG(hTest, !pCopyReq->cq_private,
+                     (hTest, "i=%u, cq_private=%p\n", i,
+                      pCopyReq->cq_private));
+    if (!g_asTestWPut[i].rcExp)
+        RTTEST_CHECK_MSG(hTest, RD(&aQueues[0])->q_first == pMBlk,
+                         (hTest, "i=%u\n", i));
+    if (g_asTestWPut[i].pfnExtra && !g_asTestWPut[i].cbDataOut)
+        if (!g_asTestWPut[i].pfnExtra(hTest, WR(&aQueues[0]), pMBlk))
+            RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Called from %s.\n",
+                         __PRETTY_FUNCTION__);
+    vbmsSolClose(RD(&aQueues[1]), 0, NULL);
+    freemsg(pMBlk);
+}
+
+
+/** Simulate sending follow-on IOCData messages to a transparent IOCtl to WPut
+ * with the parameters from table line @a i. */
+void testWPutIOCDataOut(RTTEST hTest, unsigned i)
+{
+    queue_t aQueues[2];
+    dev_t device = 0;
+    struct msgb *pMBlk = allocb(sizeof(struct copyresp), BPRI_MED);
+    struct copyresp *pCopyResp = pMBlk ? (struct copyresp *)pMBlk->b_rptr
+                                       : NULL;
+    int rc, cFormat = 0;
+
+    AssertReturnVoid(pMBlk);
+    AssertReturnVoidStmt(g_asTestWPut[i].cbDataOut, freemsg(pMBlk));
+    RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%s: i=%u\n", __PRETTY_FUNCTION__,
+                 i);
+    RT_ZERO(aQueues);
+    doInitQueues(&aQueues[0]);
+    rc = vbmsSolOpen(RD(&aQueues[0]), &device, 0, 0, NULL);
+    RTTEST_CHECK_MSG(hTest, rc == 0, (hTest, "i=%u, rc=%d\n", i, rc));
+    RTTEST_CHECK_MSG(hTest,    g_OpenNodeState.pWriteQueue
+                            == WR(&aQueues[0]), (hTest, "i=%u\n", i));
+    pMBlk->b_datap->db_type = M_IOCDATA;
+    pCopyResp->cp_cmd = g_asTestWPut[i].iIOCCmd;
+    rc = vbmsSolWPut(WR(&aQueues[0]), pMBlk);
+    RTTEST_CHECK_MSG(hTest, pMBlk->b_datap->db_type == M_IOCACK,
+                     (hTest, "i=%u, db_type=%u\n", i,
+                      (unsigned) pMBlk->b_datap->db_type));
+    if (!g_asTestWPut[i].rcExp)
+        RTTEST_CHECK_MSG(hTest, RD(&aQueues[0])->q_first == pMBlk,
+                         (hTest, "i=%u\n", i));
+    vbmsSolClose(RD(&aQueues[1]), 0, NULL);
+    freemsg(pMBlk);
+}
+#endif
+
+
+/** Data transfer direction of an IOCtl.  This is used for describing
+ * transparent IOCtls, and @a UNSPECIFIED is not a valid value for them. */
+enum IOCTLDIRECTION
+{
+    /** This IOCtl transfers no data. */
+    NONE,
+    /** This IOCtl only transfers data from user to kernel. */
+    IN,
+    /** This IOCtl only transfers data from kernel to user. */
+    OUT,
+    /** This IOCtl transfers data from user to kernel and back. */
+    BOTH,
+    /** We aren't saying anything about how the IOCtl transfers data. */
+    UNSPECIFIED
+};
+
+/**
+ * IOCtl handler function.
+ * @returns 0 on success, error code on failure.
+ * @param iCmd      The IOCtl command number.
+ * @param pvData    Buffer for the user data.
+ * @param cbBuffer  Size of the buffer in @a pvData or zero.
+ * @param pcbData   Where to set the size of the data returned.  Required for
+ *                  handlers which return data.
+ * @param prc       Where to store the return code.  Default is zero.  Only
+ *                  used for IOCtls without data for convenience of
+ *                  implemention.
+ */
+typedef int FNVBMSSOLIOCTL(PVBMSSTATE pState, int iCmd, void *pvData,
+                            size_t cbBuffer, size_t *pcbData, int *prc);
+typedef FNVBMSSOLIOCTL *PFNVBMSSOLIOCTL;
+
+/* Helpers for vbmsSolDispatchIOCtl. */
+static int vbmsSolHandleIOCtl(PVBMSSTATE pState, mblk_t *pMBlk,
+                               PFNVBMSSOLIOCTL pfnHandler,
+                               int iCmd, size_t cbCmd,
+                               enum IOCTLDIRECTION enmDirection);
+static int vbmsSolVUIDIOCtl(PVBMSSTATE pState, int iCmd, void *pvData,
+                             size_t cbBuffer, size_t *pcbData, int *prc);
+
+/** Table of supported VUID IOCtls. */
+struct
+{
+    /** The IOCtl number. */
+    int iCmd;
+    /** The size of the buffer which needs to be copied between user and kernel
+     * space, or zero if unknown (must be known for tranparent IOCtls). */
+    size_t cbBuffer;
+    /** The direction the buffer data needs to be copied.  This must be
+     * specified for transparent IOCtls. */
+    enum IOCTLDIRECTION enmDirection;
+} g_aVUIDIOCtlDescriptions[] =
+{
+   { VUIDGFORMAT,     sizeof(int),                  OUT         },
+   { VUIDSFORMAT,     sizeof(int),                  IN          },
+   { VUIDGADDR,       0,                            UNSPECIFIED },
+   { VUIDGADDR,       0,                            UNSPECIFIED },
+   { MSIOGETPARMS,    sizeof(Ms_parms),             OUT         },
+   { MSIOSETPARMS,    sizeof(Ms_parms),             IN          },
+   { MSIOSRESOLUTION, sizeof(Ms_screen_resolution), IN          },
+   { MSIOBUTTONS,     sizeof(int),                  OUT         },
+   { VUIDGWHEELCOUNT, sizeof(int),                  OUT         },
+   { VUIDGWHEELINFO,  0,                            UNSPECIFIED },
+   { VUIDGWHEELSTATE, 0,                            UNSPECIFIED },
+   { VUIDSWHEELSTATE, 0,                            UNSPECIFIED }
+};
+
+/**
+ * Handle a STREAMS IOCtl message for our driver on the write stream.  This
+ * function takes care of the IOCtl logic only and does not call qreply() or
+ * miocnak() at all - the caller must call these on success or failure
+ * respectively.
+ * @returns  0 on success or the IOCtl error code on failure.
+ * @param  pState       pointer to the state structure.
+ * @param  pMBlk        pointer to the STREAMS message block structure.
+ */
+static int vbmsSolDispatchIOCtl(PVBMSSTATE pState, mblk_t *pMBlk)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+    int iCmd = pIOCBlk->ioc_cmd, iCmdType = iCmd & (0xff << 8);
+    size_t cbBuffer;
+    enum IOCTLDIRECTION enmDirection;
+
+    LogRelFlowFunc((DEVICE_NAME "::pIOCBlk=%p, iCmdType=%c, iCmd=0x%x\n",
+                    pIOCBlk, (char) (iCmdType >> 8), (unsigned)iCmd));
+    switch (iCmdType)
+    {
+        case MSIOC:
+        case VUIOC:
+        {
+            unsigned i;
+
+            for (i = 0; i < RT_ELEMENTS(g_aVUIDIOCtlDescriptions); ++i)
+                if (g_aVUIDIOCtlDescriptions[i].iCmd == iCmd)
+                {
+                    cbBuffer     = g_aVUIDIOCtlDescriptions[i].cbBuffer;
+                    enmDirection = g_aVUIDIOCtlDescriptions[i].enmDirection;
+                    return vbmsSolHandleIOCtl(pState, pMBlk,
+                                              vbmsSolVUIDIOCtl, iCmd,
+                                              cbBuffer, enmDirection);
+                }
+            return EINVAL;
+        }
+        default:
+            return ENOTTY;
+    }
+}
+
+
+/* Helpers for vbmsSolHandleIOCtl. */
+static int vbmsSolHandleIOCtlData(PVBMSSTATE pState, mblk_t *pMBlk,
+                                  PFNVBMSSOLIOCTL pfnHandler, int iCmd,
+                                  size_t cbCmd,
+                                  enum IOCTLDIRECTION enmDirection);
+
+static int vbmsSolHandleTransparentIOCtl(PVBMSSTATE pState, mblk_t *pMBlk,
+                                         PFNVBMSSOLIOCTL pfnHandler,
+                                         int iCmd, size_t cbCmd,
+                                         enum IOCTLDIRECTION enmDirection);
+
+static int vbmsSolHandleIStrIOCtl(PVBMSSTATE pState, mblk_t *pMBlk,
+                                   PFNVBMSSOLIOCTL pfnHandler, int iCmd);
+
+static void vbmsSolAcknowledgeIOCtl(mblk_t *pMBlk, int cbData, int rc)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+
+    pMBlk->b_datap->db_type = M_IOCACK;
+    pIOCBlk->ioc_count = cbData;
+    pIOCBlk->ioc_rval = rc;
+    pIOCBlk->ioc_error = 0;
+}
+
+/**
+ * Generic code for handling STREAMS-specific IOCtl logic and boilerplate.  It
+ * calls the IOCtl handler passed to it without the handler having to be aware
+ * of STREAMS structures, or whether this is a transparent (traditional) or an
+ * I_STR (using a STREAMS structure to describe the data) IOCtl.  With the
+ * caveat that we only support transparent IOCtls which pass all data in a
+ * single buffer of a fixed size (I_STR IOCtls are restricted to a single
+ * buffer anyway, but the caller can choose the buffer size).
+ * @returns  0 on success or the IOCtl error code on failure.
+ * @param  pState         pointer to the state structure.
+ * @param  pMBlk          pointer to the STREAMS message block structure.
+ * @param  pfnHandler     pointer to the right IOCtl handler function for this
+ *                        IOCtl number.
+ * @param  iCmd           IOCtl command number.
+ * @param  cbCmd          size of the user space buffer for this IOCtl number,
+ *                        used for processing transparent IOCtls.  Pass zero
+ *                        for IOCtls with no maximum buffer size (which will
+ *                        not be able to be handled as transparent) or with
+ *                        no argument.
+ * @param  enmDirection   data transfer direction of the IOCtl.
+ */
+static int vbmsSolHandleIOCtl(PVBMSSTATE pState, mblk_t *pMBlk,
+                              PFNVBMSSOLIOCTL pfnHandler, int iCmd,
+                              size_t cbCmd, enum IOCTLDIRECTION enmDirection)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%d, enmDirection=%d\n",
+                 (unsigned)iCmd, (int)cbCmd, (int)enmDirection));
+    if (pMBlk->b_datap->db_type == M_IOCDATA)
+        return vbmsSolHandleIOCtlData(pState, pMBlk, pfnHandler, iCmd,
+                                      cbCmd, enmDirection);
+    else if (   pMBlk->b_datap->db_type == M_IOCTL
+             && pIOCBlk->ioc_count == TRANSPARENT)
+        return vbmsSolHandleTransparentIOCtl(pState, pMBlk, pfnHandler,
+                                             iCmd, cbCmd, enmDirection);
+    else if (pMBlk->b_datap->db_type == M_IOCTL)
+        return vbmsSolHandleIStrIOCtl(pState, pMBlk, pfnHandler, iCmd);
+    return EINVAL;
+}
+
+
+/**
+ * Helper for vbmsSolHandleIOCtl.  This rather complicated-looking
+ * code is basically the standard boilerplate for handling any streams IOCtl
+ * additional data, which we currently only use for transparent IOCtls.
+ * @copydoc vbmsSolHandleIOCtl
+ */
+static int vbmsSolHandleIOCtlData(PVBMSSTATE pState, mblk_t *pMBlk,
+                                  PFNVBMSSOLIOCTL pfnHandler, int iCmd,
+                                  size_t cbCmd,
+                                  enum IOCTLDIRECTION enmDirection)
+{
+    struct copyresp *pCopyResp = (struct copyresp *)pMBlk->b_rptr;
+
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%d, enmDirection=%d, cp_rval=%d, cp_private=%p\n",
+                 (unsigned)iCmd, (int)cbCmd, (int)enmDirection,
+                 (int)(uintptr_t)pCopyResp->cp_rval,
+                 (void *)pCopyResp->cp_private));
+    if (pCopyResp->cp_rval)  /* cp_rval is a pointer used as a boolean. */
+        return EAGAIN;
+    if ((pCopyResp->cp_private && enmDirection == BOTH) || enmDirection == IN)
+    {
+        size_t cbData = 0;
+        void *pvData = NULL;
+        int err;
+
+        if (!pMBlk->b_cont)
+            return EINVAL;
+        pvData = pMBlk->b_cont->b_rptr;
+        err = pfnHandler(pState, iCmd, pvData, cbCmd, &cbData, NULL);
+        if (!err && enmDirection == BOTH)
+            mcopyout(pMBlk, NULL, cbData, pCopyResp->cp_private, NULL);
+        else if (!err && enmDirection == IN)
+            vbmsSolAcknowledgeIOCtl(pMBlk, 0, 0);
+        if ((err || enmDirection == IN) && pCopyResp->cp_private)
+            freemsg(pCopyResp->cp_private);
+        return err;
+    }
+    else
+    {
+        if (pCopyResp->cp_private)
+            freemsg(pCopyResp->cp_private);
+        AssertReturn(enmDirection == OUT || enmDirection == BOTH, EINVAL);
+        vbmsSolAcknowledgeIOCtl(pMBlk, 0, 0);
+        return 0;
+    }
+}
+
+/**
+ * Helper for vbmsSolHandleIOCtl.  This rather complicated-looking
+ * code is basically the standard boilerplate for handling transparent IOCtls,
+ * that is, IOCtls which are not re-packed inside STREAMS IOCtls.
+ * @copydoc vbmsSolHandleIOCtl
+ */
+int vbmsSolHandleTransparentIOCtl(PVBMSSTATE pState, mblk_t *pMBlk,
+                                  PFNVBMSSOLIOCTL pfnHandler, int iCmd,
+                                  size_t cbCmd,
+                                  enum IOCTLDIRECTION enmDirection)
+{
+    int err = 0, rc = 0;
+    size_t cbData = 0;
+
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%d, enmDirection=%d\n",
+                 (unsigned)iCmd, (int)cbCmd, (int)enmDirection));
+    if (   (enmDirection != NONE && !pMBlk->b_cont)
+        || enmDirection == UNSPECIFIED)
+        return EINVAL;
+    if (enmDirection == IN || enmDirection == BOTH)
+    {
+        void *pUserAddr = NULL;
+        /* We only need state data if there is something to copy back. */
+        if (enmDirection == BOTH)
+            pUserAddr = *(void **)pMBlk->b_cont->b_rptr;
+            mcopyin(pMBlk, pUserAddr /* state data */, cbCmd, NULL);
+        }
+        else if (enmDirection == OUT)
+    {
+        mblk_t *pMBlkOut = allocb(cbCmd, BPRI_MED);
+        void *pvData;
+
+        if (!pMBlkOut)
+            return EAGAIN;
+        pvData = pMBlkOut->b_rptr;
+        err = pfnHandler(pState, iCmd, pvData, cbCmd, &cbData, NULL);
+        if (!err)
+            mcopyout(pMBlk, NULL, cbData, NULL, pMBlkOut);
+        else
+            freemsg(pMBlkOut);
+    }
+    else
+    {
+        AssertReturn(enmDirection == NONE, EINVAL);
+        err = pfnHandler(pState, iCmd, NULL, 0, NULL, &rc);
+        if (!err)
+            vbmsSolAcknowledgeIOCtl(pMBlk, 0, rc);
+    }
+    return err;
+}
+
+/**
+ * Helper for vbmsSolHandleIOCtl.  This rather complicated-looking
+ * code is basically the standard boilerplate for handling any streams IOCtl.
+ * @copydoc vbmsSolHandleIOCtl
+ */
+static int vbmsSolHandleIStrIOCtl(PVBMSSTATE pState, mblk_t *pMBlk,
+                                  PFNVBMSSOLIOCTL pfnHandler, int iCmd)
+{
+    struct iocblk *pIOCBlk = (struct iocblk *)pMBlk->b_rptr;
+    uint_t cbBuffer = pIOCBlk->ioc_count;
+    void *pvData = NULL;
+    int err, rc = 0;
+    size_t cbData = 0;
+
+    LogFlowFunc(("iCmd=0x%x, cbBuffer=%u, b_cont=%p\n",
+                 (unsigned)iCmd, cbBuffer, (void *)pMBlk->b_cont));
+    if (cbBuffer && !pMBlk->b_cont)
+        return EINVAL;
+    /* Repack the whole buffer into a single message block if needed. */
+    if (cbBuffer)
+    {
+        err = miocpullup(pMBlk, cbBuffer);
+        if (err)
+            return err;
+        pvData = pMBlk->b_cont->b_rptr;
+    }
+    else if (pMBlk->b_cont)  /* consms forgets to set ioc_count. */
+    {
+        pvData = pMBlk->b_cont->b_rptr;
+        cbBuffer =   pMBlk->b_cont->b_datap->db_lim
+                   - pMBlk->b_cont->b_datap->db_base;
+    }
+    err = pfnHandler(pState, iCmd, pvData, cbBuffer, &cbData, &rc);
+    if (!err)
+    {
+        LogRelFlowFunc(("pMBlk=%p, pMBlk->b_datap=%p, pMBlk->b_rptr=%p\n",
+                        pMBlk, pMBlk->b_datap, pMBlk->b_rptr));
+        vbmsSolAcknowledgeIOCtl(pMBlk, cbData, rc);
+    }
+    return err;
+}
+
+
+/**
+ * Handle a VUID input device IOCtl.
+ * @copydoc FNVBMSSOLIOCTL
+ */
+static int vbmsSolVUIDIOCtl(PVBMSSTATE pState, int iCmd, void *pvData,
+                             size_t cbBuffer, size_t *pcbData, int *prc)
+{
+    LogRelFlowFunc((DEVICE_NAME "::pvData=%p " /* no '\n' */, pvData));
+    switch (iCmd)
+    {
+        case VUIDGFORMAT:
+        {
+            LogRelFlowFunc(("VUIDGFORMAT\n"));
+            if (cbBuffer < sizeof(int))
+                return EINVAL;
+            *(int *)pvData = VUID_FIRM_EVENT;
+            *pcbData = sizeof(int);
+            return 0;
+        }
+        case VUIDSFORMAT:
+            LogRelFlowFunc(("VUIDSFORMAT\n"));
+            /* We define our native format to be VUID_FIRM_EVENT, so there
+             * is nothing more to do and we exit here on success or on
+             * failure. */
+            return 0;
+        case VUIDGADDR:
+        case VUIDSADDR:
+            LogRelFlowFunc(("VUIDGADDR/VUIDSADDR\n"));
+            return ENOTTY;
+        case MSIOGETPARMS:
+        {
+            Ms_parms parms = { 0 };
+
+            LogRelFlowFunc(("MSIOGETPARMS\n"));
+            if (cbBuffer < sizeof(Ms_parms))
+                return EINVAL;
+            *(Ms_parms *)pvData = parms;
+            *pcbData = sizeof(Ms_parms);
+            return 0;
+        }
+        case MSIOSETPARMS:
+            LogRelFlowFunc(("MSIOSETPARMS\n"));
+            return 0;
+        case MSIOSRESOLUTION:
+        {
+            Ms_screen_resolution *pResolution = (Ms_screen_resolution *)pvData;
+            int rc;
+
+            LogRelFlowFunc(("MSIOSRESOLUTION, cbBuffer=%d, sizeof(Ms_screen_resolution)=%d\n",
+                            (int) cbBuffer,
+                            (int) sizeof(Ms_screen_resolution)));
+            if (cbBuffer < sizeof(Ms_screen_resolution))
+                return EINVAL;
+            LogRelFlowFunc(("%dx%d\n", pResolution->width,
+                            pResolution->height));
+            pState->cMaxScreenX = pResolution->width  - 1;
+            pState->cMaxScreenY = pResolution->height - 1;
+            /* Note: we don't disable this again until session close. */
+            rc = VbglR0SetMouseStatus(  VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
+                                      | VMMDEV_MOUSE_NEW_PROTOCOL);
+            if (RT_SUCCESS(rc))
+                return 0;
+            pState->cMaxScreenX = 0;
+            pState->cMaxScreenY = 0;
+            return ENODEV;
+        }
+        case MSIOBUTTONS:
+        {
+            LogRelFlowFunc(("MSIOBUTTONS\n"));
+            if (cbBuffer < sizeof(int))
+                return EINVAL;
+            *(int *)pvData = 0;
+            *pcbData = sizeof(int);
+            return 0;
+        }
+        case VUIDGWHEELCOUNT:
+        {
+            LogRelFlowFunc(("VUIDGWHEELCOUNT\n"));
+            if (cbBuffer < sizeof(int))
+                return EINVAL;
+            *(int *)pvData = 0;
+            *pcbData = sizeof(int);
+            return 0;
+        }
+        case VUIDGWHEELINFO:
+        case VUIDGWHEELSTATE:
+        case VUIDSWHEELSTATE:
+            LogRelFlowFunc(("VUIDGWHEELINFO/VUIDGWHEELSTATE/VUIDSWHEELSTATE\n"));
+            return EINVAL;
+        default:
+            LogRelFlowFunc(("Invalid IOCtl command %x\n", iCmd));
+            return EINVAL;
+    }
+}
+
+
+#ifdef TESTCASE
+int main(void)
+{
+    RTTEST hTest;
+    int rc = RTTestInitAndCreate("tstVBoxGuest-solaris", &hTest);
+    if (rc)
+        return rc;
+    RTTestBanner(hTest);
+    test_init(hTest);
+    testOpenClose(hTest);
+    testWPut(hTest);
+
+    /*
+     * Summary.
+     */
+    return RTTestSummaryAndDestroy(hTest);
+}
+#endif
+
diff --git a/src/VBox/Additions/solaris/Mouse/vboxms.conf b/src/VBox/Additions/solaris/Mouse/vboxms.conf
new file mode 100644
index 00000000..40c2ab47
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/vboxms.conf
@@ -0,0 +1,32 @@
+# $Id: vboxms.conf $
+## @file
+# OpenSolaris Guest Mouse Driver Configuration
+#
+
+#
+# Copyright (C) 2012-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+# This needs to go into /usr/kernel/drv,
+# while the 64-bit driver object goes into the amd64
+# subdirectory (32-bit drivers goes into the same
+# directory).
+#
+name="vboxms" parent="pseudo" instance=0;
diff --git a/src/VBox/Additions/solaris/Mouse/vboxmslnk.c b/src/VBox/Additions/solaris/Mouse/vboxmslnk.c
new file mode 100644
index 00000000..e54dea22
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/vboxmslnk.c
@@ -0,0 +1,121 @@
+/* $Id: vboxmslnk.c $ */
+/** @file
+ * VirtualBox Guest Additions Mouse Driver for Solaris: user space loader tool.
+ */
+
+/*
+ * Copyright (C) 2012-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#include <VBox/version.h>
+#include <iprt/buildconfig.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stropts.h>
+#include <unistd.h>
+
+static void handleArgs(int argc, char *argv[], int *pfNoLogo);
+
+int main(int argc, char *argv[])
+{
+    int fNoLogo, hVBoxMS, hConsMS, idConnection;
+
+    handleArgs(argc, argv, &fNoLogo);
+    /* Open our pointer integration driver (vboxms). */
+    hVBoxMS = open("/dev/vboxms", O_RDWR);
+    if (hVBoxMS < 0)
+    {
+        printf("Failed to open /dev/vboxms - please make sure that the node exists and that\n"
+               "you have permission to open it.  The error reported was:\n"
+               "%s\n", strerror(errno));
+        exit(1);
+    }
+    /* Open the Solaris virtual mouse driver (consms). */
+    hConsMS = open("/dev/mouse", O_RDWR);
+    if (hConsMS < 0)
+    {
+        printf("Failed to open /dev/mouse - please make sure that the node exists and that\n"
+               "you have permission to open it.  The error reported was:\n"
+               "%s\n", strerror(errno));
+        exit(1);
+    }
+    /* Link vboxms to consms from below.  What this means is that vboxms is
+     * added to the list of input sources multiplexed by consms, and vboxms
+     * will receive any control messages (such as information about guest
+     * resolution changes) sent to consms.  The link can only be broken
+     * explicitly using the connection ID returned from the IOCtl. */
+    idConnection = ioctl(hConsMS, I_PLINK, hVBoxMS);
+    if (idConnection < 0)
+    {
+        printf("Failed to add /dev/vboxms (the pointer integration driver) to /dev/mouse\n"
+               "(the Solaris virtual master mouse).  The error reported was:\n"
+               "%s\n", strerror(errno));
+        exit(1);
+    }
+    close(hVBoxMS);
+    if (!fNoLogo)
+        printf("Successfully enabled pointer integration.  Connection ID number to the\n"
+               "Solaris virtual master mouse:\n");
+    printf("%d\n", idConnection);
+    exit(0);
+}
+
+void handleArgs(int argc, char *argv[], int *pfNoLogo)
+{
+    int fNoLogo = 0, fShowUsage = 0, fShowVersion = 0;
+
+    if (argc != 1 && argc != 2)
+        fShowUsage = 1;
+    if (argc == 2)
+    {
+        if (!strcmp(argv[1], "--nologo"))
+            fNoLogo = 1;
+        else if (!strcmp(argv[1], "-V") || !strcmp(argv[1], "--version"))
+            fShowVersion = 1;
+        else
+            fShowUsage = 1;
+    }
+    if (fShowVersion)
+    {
+        printf("%sr%u\n", VBOX_VERSION_STRING, RTBldCfgRevision());
+        exit(0);
+    }
+    if (!fNoLogo)
+        printf(VBOX_PRODUCT
+               " Guest Additions enabling utility for Solaris pointer\nintegration Version "
+               VBOX_VERSION_STRING "\n"
+               "(C) " VBOX_C_YEAR " " VBOX_VENDOR "\n"
+               "All rights reserved.\n\n");
+    if (fShowUsage)
+    {
+        printf("Usage:\n  -V|--version  print the tool version.\n"
+               "  --nologo      do not display the logo text and only output the connection\n"
+               "                ID number needed to disable pointer integration\n"
+               "                again.\n"
+               "  -h|--help     display this help text.\n");
+        exit(0);
+    }
+    *pfNoLogo = fNoLogo;
+}
+
diff --git a/src/VBox/Additions/solaris/Mouse/vboxmslnk.xml b/src/VBox/Additions/solaris/Mouse/vboxmslnk.xml
new file mode 100644
index 00000000..6c1cf95b
--- /dev/null
+++ b/src/VBox/Additions/solaris/Mouse/vboxmslnk.xml
@@ -0,0 +1,80 @@
+<?xml version='1.0'?>
+<!--
+#
+# Solaris SMF service manifest for VBoxService (timesync).
+#
+    Copyright (C) 2012-2020 Oracle Corporation
+
+    This file is part of VirtualBox Open Source Edition (OSE), as
+    available from http://www.virtualbox.org. This file is free software;
+    you can redistribute it and/or modify it under the terms of the GNU
+    General Public License (GPL) as published by the Free Software
+    Foundation, in version 2 as it comes in the "COPYING" file of the
+    VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+    hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+
+    The contents of this file may alternatively be used under the terms
+    of the Common Development and Distribution License Version 1.0
+    (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+    VirtualBox OSE distribution, in which case the provisions of the
+    CDDL are applicable instead of those of the GPL.
+
+    You may elect to license modified versions of this file under the
+    terms and conditions of either the GPL or the CDDL or both.
+-->
+<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
+
+<service_bundle type='manifest' name='SUNWvboxguest:vboxmslnk'>
+
+<service
+    name='application/virtualbox/vboxmslnk'
+    type='service'
+    version='1'>
+
+    <create_default_instance enabled='false' />
+
+    <single_instance/>
+
+    <!-- Wait for devices to be initialized as we depend on vboxms (pseudo) -->
+    <dependency
+        name='milestone'
+        grouping='require_all'
+        restart_on='none'
+        type='service'>
+        <service_fmri value='svc:/milestone/devices:default' />
+    </dependency>
+
+    <!-- Wait for local filesystems to be mounted (just to be safe, don't start too early) -->
+    <dependency
+        name='filesystem-local'
+        grouping='require_all'
+        restart_on='none'
+        type='service'>
+        <service_fmri value='svc:/system/filesystem/local:default' />
+    </dependency>
+
+    <exec_method
+        type='method'
+        name='start'
+        exec='/usr/sbin/vboxmslnk'
+        timeout_seconds='30' />
+
+    <exec_method
+        type='method'
+        name='stop'
+        exec=':true'
+        timeout_seconds='60' />
+
+    <property_group name='startd' type='framework'>
+        <propval name='duration' type='astring' value='transient' />
+    </property_group>
+
+    <template>
+        <common_name>
+            <loctext xml:lang='C'>VirtualBox Mouse module link.</loctext>
+        </common_name>
+    </template>
+</service>
+
+</service_bundle>
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/Makefile.kmk b/src/VBox/Additions/solaris/SharedFolders/Makefile.kmk
new file mode 100644
index 00000000..c361f1a8
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/Makefile.kmk
@@ -0,0 +1,103 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the Solaris Shared folder kernel module.
+#
+
+#
+# Copyright (C) 2008-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+SUB_DEPTH = ../../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#ifneq ($(KBUILD_HOST),solaris)
+#$(error "The Solaris guest additions can only be built on Solaris!")
+#endif
+
+#
+# vboxfs - The Shared Folder Driver
+#
+SYSMODS.solaris      += vboxfs
+vboxfs_TEMPLATE      = VBOXGUESTR0
+vboxfs_DEFS          = VBOX_WITH_HGCM VBOX_SVN_REV=$(VBOX_SVN_REV)
+vboxfs_DEPS         += $(VBOX_SVN_REV_KMK)
+vboxfs_INCS         := \
+	.
+vboxfs_SOURCES       = \
+	vboxfs_vfs.c \
+	vboxfs_vnode.c \
+	vboxfs_prov.c
+vboxfs_LIBS          = \
+	$(VBOX_LIB_VBGL_R0)
+ifeq ($(KBUILD_HOST),solaris)
+ vboxfs_LDFLAGS.solaris   += -N drv/vboxguest -N misc/ctf
+else
+ vboxfs_SOURCES           += deps.asm
+ vboxfs_deps.asm_ASFLAGS   = -f bin -g null
+endif
+if  ($(VBOX_SOLARIS_11_UPDATE_VERSION) > 1 \
+ || ($(VBOX_SOLARIS_11_UPDATE_VERSION) == 1 && $(VBOX_SOLARIS_11_BUILD_VERSION) >= 10))
+vboxfs_DEFS         += VBOX_VFS_EXTENDED_POLICY
+endif
+
+
+ifndef VBOX_OSE
+#
+# vboxfs_s10 - The Shared Folder Driver for Solaris 10
+#
+SYSMODS.solaris      += vboxfs_s10
+vboxfs_s10_TEMPLATE      = VBOXGUESTR0
+vboxfs_s10_DEFS          = VBOX_WITH_HGCM VBOX_VFS_SOLARIS_10U6 VBOX_SVN_REV=$(VBOX_SVN_REV)
+vboxfs_s10_DEPS         += $(VBOX_SVN_REV_KMK)
+vboxfs_s10_INCS         := solaris10/
+vboxfs_s10_SOURCES       = \
+	vboxfs_vfs.c \
+	vboxfs_vnode.c \
+	vboxfs_prov.c
+vboxfs_s10_LIBS          = \
+	$(VBOX_LIB_VBGL_R0) \
+	$(VBOX_LIB_IPRT_GUEST_R0)
+ifeq ($(KBUILD_HOST),solaris)
+ vboxfs_s10_LDFLAGS         += -N drv/vboxguest -N misc/ctf
+else
+ vboxfs_s10_SOURCES         += deps.asm
+ vboxfs_s10_deps.asm_ASFLAGS = -f bin -g null
+endif
+endif # VBOX_OSE
+
+
+#
+# mount - Userland mount wrapper for vboxfs
+#
+PROGRAMS                += vboxfsmount
+vboxfsmount_TEMPLATE    = NewVBoxGuestR3Exe
+vboxfsmount_SOURCES     = vboxfs_mount.c
+
+
+#
+# Load script.
+#
+INSTALLS += vboxfsload
+vboxfsload_TEMPLATE = VBOXGUESTR0
+vboxfsload_EXEC_SOURCES = loadfs.sh
+
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/deps.asm b/src/VBox/Additions/solaris/SharedFolders/deps.asm
new file mode 100644
index 00000000..8cd46f5f
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/deps.asm
@@ -0,0 +1,39 @@
+; $Id: deps.asm $
+;; @file
+; Solaris kernel module dependency
+;
+
+;
+; Copyright (C) 2012-2020 Oracle Corporation
+;
+; This file is part of VirtualBox Open Source Edition (OSE), as
+; available from http://www.virtualbox.org. This file is free software;
+; you can redistribute it and/or modify it under the terms of the GNU
+; General Public License (GPL) as published by the Free Software
+; Foundation, in version 2 as it comes in the "COPYING" file of the
+; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+; VirtualBox OSE distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+
+%include "iprt/solaris/kmoddeps.mac"
+
+kmoddeps_header  ; ELF header, section table and shared string table
+
+kmoddeps_dynstr_start  ; ELF .dynstr section
+kmoddeps_dynstr_string str_misc_ctf, "misc/ctf"
+kmoddeps_dynstr_string str_drv_vboxguest, "drv/vboxguest"
+kmoddeps_dynstr_end
+
+kmoddeps_dynamic_start  ; ELF .dynamic section
+kmoddeps_dynamic_needed str_misc_ctf
+kmoddeps_dynamic_needed str_drv_vboxguest
+kmoddeps_dynamic_end
diff --git a/src/VBox/Additions/solaris/SharedFolders/loadfs.sh b/src/VBox/Additions/solaris/SharedFolders/loadfs.sh
new file mode 100755
index 00000000..3da02bf8
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/loadfs.sh
@@ -0,0 +1,95 @@
+#!/bin/bash
+# $Id: loadfs.sh $
+## @file
+# For GA development.
+#
+
+#
+# Copyright (C) 2006-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+DRVNAME="vboxfs"
+MOUNTHLP="vboxfsmount"
+
+DRVFILE=`dirname "$0"`
+DRVFILE=`cd "$DRVFILE" && pwd`
+MOUNTHLPFILE="$DRVFILE/$MOUNTHLP"
+DRVFILE="$DRVFILE/$DRVNAME"
+if [ ! -f "$DRVFILE" ]; then
+    echo "loadfs.sh: Cannot find $DRVFILE or it's not a file..."
+    exit 1;
+fi
+if [ ! -f "$MOUNTHLPFILE" ]; then
+    echo "load.sh: Cannot find $MOUNTHLPFILE or it's not a file..."
+    exit 1;
+fi
+
+SUDO=sudo
+#set -x
+
+# Unload the driver if loaded.
+for drv in $DRVNAME;
+do
+    LOADED=`modinfo | grep -w "$drv"`
+    if test -n "$LOADED"; then
+        MODID=`echo "$LOADED" | cut -d ' ' -f 1`
+        $SUDO modunload -i $MODID;
+        LOADED=`modinfo | grep -w "$drv"`;
+        if test -n "$LOADED"; then
+            echo "load.sh: failed to unload $drv";
+            dmesg | tail
+            exit 1;
+        fi
+    fi
+done
+
+#
+# Remove old stuff.
+#
+MY_RC=1
+set -e
+$SUDO rm -f \
+    "/usr/kernel/fs/${DRVNAME}" \
+    "/usr/kernel/fs/amd64/${DRVNAME}" \
+    "/etc/fs/vboxfs/mount"
+sync
+set +e
+
+#
+# Install the mount program.
+#
+if [ ! -d /etc/fs/vboxfs ]; then
+    $SUDO mkdir -p /etc/fs/vboxfs
+fi
+$SUDO ln -sf "$MOUNTHLPFILE" /etc/fs/vboxfs/mount
+
+#
+# Load the module. We can load it without copying it to /usr/kernel/fs/.
+#
+if $SUDO modload "$DRVFILE"; then
+    sync
+    MY_RC=0
+else
+    dmesg | tail
+    echo "load.sh: add_drv failed."
+fi
+
+exit $MY_RC;
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs.h b/src/VBox/Additions/solaris/SharedFolders/vboxfs.h
new file mode 100644
index 00000000..5c674330
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs.h
@@ -0,0 +1,96 @@
+/* $Id: vboxfs.h $ */
+/** @file
+ * VirtualBox File System Driver for Solaris Guests, Internal Header.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_h
+#define GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_HOST_NAME   256
+#define MAX_NLS_NAME    32
+/** Default stat cache ttl (in ms) */
+#define DEF_STAT_TTL_MS 200
+
+/** The module name. */
+#define DEVICE_NAME              "vboxfs"
+
+#ifdef _KERNEL
+
+#include <VBox/VBoxGuestLibSharedFolders.h>
+#include <sys/vfs.h>
+
+/** VNode for VBoxVFS */
+typedef struct vboxvfs_vnode
+{
+    vnode_t     *pVNode;
+    vattr_t     Attr;
+    SHFLSTRING  *pPath;
+    kmutex_t    MtxContents;
+} vboxvfs_vnode_t;
+
+
+/** Per-file system mount instance data. */
+typedef struct vboxvfs_globinfo
+{
+    VBGLSFMAP       Map;
+    int             Ttl;
+    int             Uid;
+    int             Gid;
+    vfs_t           *pVFS;
+    vboxvfs_vnode_t *pVNodeRoot;
+    kmutex_t        MtxFS;
+} vboxvfs_globinfo_t;
+
+extern struct vnodeops *g_pVBoxVFS_vnodeops;
+extern const fs_operation_def_t g_VBoxVFS_vnodeops_template[];
+extern VBGLSFCLIENT g_VBoxVFSClient;
+
+/** Helper functions */
+extern int vboxvfs_Stat(const char *pszCaller, vboxvfs_globinfo_t *pVBoxVFSGlobalInfo, SHFLSTRING *pPath,
+                        PSHFLFSOBJINFO pResult, boolean_t fAllowFailure);
+extern void vboxvfs_InitVNode(vboxvfs_globinfo_t *pVBoxVFSGlobalInfo, vboxvfs_vnode_t *pVBoxVNode,
+                              PSHFLFSOBJINFO pFSInfo);
+
+
+/** Helper macros */
+#define VFS_TO_VBOXVFS(vfs)      ((vboxvfs_globinfo_t *)((vfs)->vfs_data))
+#define VBOXVFS_TO_VFS(vboxvfs)  ((vboxvfs)->pVFS)
+#define VN_TO_VBOXVN(vnode)      ((vboxvfs_vnode_t *)((vnode)->v_data))
+#define VBOXVN_TO_VN(vboxvnode)  ((vboxvnode)->pVNode)
+
+#endif /* _KERNEL */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_h */
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_mount.c b/src/VBox/Additions/solaris/SharedFolders/vboxfs_mount.c
new file mode 100644
index 00000000..2a0e7d53
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_mount.c
@@ -0,0 +1,169 @@
+/* $Id: vboxfs_mount.c $ */
+/** @file
+ * VirtualBox File System Mount Helper, Solaris host.
+ * Userspace mount wrapper that parses mount (or user-specified) options
+ * and passes it to mount(2) syscall
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <sys/vfs.h>
+#include <sys/mount.h>
+
+#include "vboxfs.h"
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+static char g_achOptBuf[MAX_MNTOPT_STR] = { '\0', };
+static const int g_RetErr = 33;
+static const int g_RetMagic = 2;
+static const int g_RetOK = 0;
+
+static void Usage(char *pszName)
+{
+    fprintf(stderr, "Usage: %s [OPTIONS] NAME MOUNTPOINT\n"
+           "Mount the VirtualBox shared folder NAME from the host system to MOUNTPOINT.\n"
+           "\n"
+           "  -w                    mount the shared folder writable (the default)\n"
+           "  -r                    mount the shared folder read-only\n"
+           "  -o OPTION[,OPTION...] use the mount options specified\n"
+           "\n", pszName);
+    fprintf(stderr, "Available mount options are:\n"
+           "\n"
+           "     rw                 mount writable (the default)\n"
+           "     ro                 mount read only\n"
+           "     uid=UID            set the default file owner user id to UID\n"
+           "     gid=GID            set the default file owner group id to GID\n");
+    fprintf(stderr,
+           "     dmode=MODE         override the mode for all directories (octal) to MODE\n"
+           "     fmode=MODE         override the mode for all regular files (octal) to MODE\n"
+           "     umask=UMASK        set the umask (bitmask of permissions not present) in (octal) UMASK\n"
+           "     dmask=UMASK        set the umask applied to directories only in (octal) UMASK\n"
+           "     fmask=UMASK        set the umask applied to regular files only in (octal) UMASK\n"
+           "     stat_ttl=TTL       set the \"time to live\" (in ms) for the stat caches (default %d)\n", DEF_STAT_TTL_MS);
+    fprintf(stderr,
+           "     fsync              honor fsync calls instead of ignoring them\n"
+           "     ttl=TTL            set the \"time to live\" to TID for the dentry\n"
+           "     iocharset CHARSET  use the character set CHARSET for i/o operations (default utf8)\n"
+           "     convertcp CHARSET  convert the shared folder name from the character set CHARSET to utf8\n\n"
+           "Less common used options:\n"
+           "     noexec,exec,nodev,dev,nosuid,suid\n");
+    exit(1);
+}
+
+int main(int argc, char **argv)
+{
+    char *pszName      = NULL;
+    char *pszSpecial   = NULL;
+    char *pszMount     = NULL;
+    char  achType[MAXFIDSZ];
+    int   c = '?';
+    int   rc = -1;
+    int   parseError = 0;
+    int   mntFlags = 0;
+    int   quietFlag = 0;
+
+    pszName = strrchr(argv[0], '/');
+    pszName = pszName ? pszName + 1 : argv[0];
+    snprintf(achType, sizeof(achType), "%s_%s", DEVICE_NAME, pszName);
+
+    while ((c = getopt(argc, argv, "o:rmoQ")) != EOF)
+    {
+        switch (c)
+        {
+            case '?':
+            {
+                parseError = 1;
+                break;
+            }
+
+            case 'q':
+            {
+                quietFlag = 1;
+                break;
+            }
+
+            case 'r':
+            {
+                mntFlags |= MS_RDONLY;
+                break;
+            }
+
+            case 'O':
+            {
+                mntFlags |= MS_OVERLAY;
+                break;
+            }
+
+            case 'm':
+            {
+                mntFlags |= MS_NOMNTTAB;
+                break;
+            }
+
+            case 'o':
+            {
+                if (strlcpy(g_achOptBuf, optarg, sizeof(g_achOptBuf)) >= sizeof(g_achOptBuf))
+                {
+                    fprintf(stderr, "%s: invalid argument: %s\n", pszName, optarg);
+                    return g_RetMagic;
+                }
+                break;
+            }
+
+            default:
+            {
+                Usage(pszName);
+                break;
+            }
+        }
+    }
+
+    if (   argc - optind != 2
+        || parseError)
+    {
+        Usage(pszName);
+    }
+
+    pszSpecial = argv[argc - 2];
+    pszMount = argv[argc - 1];
+
+    rc = mount(pszSpecial, pszMount, mntFlags | MS_OPTIONSTR, DEVICE_NAME, NULL, 0, g_achOptBuf, sizeof(g_achOptBuf));
+    if (rc)
+    {
+        fprintf(stderr, "mount:");
+        perror(pszSpecial);
+        return g_RetErr;
+    }
+
+    return g_RetOK;
+}
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.c b/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.c
new file mode 100644
index 00000000..f53ba73e
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.c
@@ -0,0 +1,1060 @@
+/* $Id: vboxfs_prov.c $ */
+/** @file
+ * VirtualBox File System for Solaris Guests, provider implementation.
+ * Portions contributed by: Ronald.
+ */
+
+/*
+ * Copyright (C) 2008-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+/*
+ * Provider interfaces for shared folder file system.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mntent.h>
+#include <sys/param.h>
+#include <sys/modctl.h>
+#include <sys/mount.h>
+#include <sys/policy.h>
+#include <sys/atomic.h>
+#include <sys/sysmacros.h>
+#include <sys/ddi.h>
+#include <sys/sunddi.h>
+#include <sys/dirent.h>
+#include <sys/file.h>
+#undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
+
+#include "vboxfs_prov.h"
+#include <iprt/err.h>
+
+#define	SFPROV_VERSION	1
+
+static VBGLSFCLIENT vbox_client;
+
+static int sfprov_vbox2errno(int rc)
+{
+	if (rc == VERR_ACCESS_DENIED)
+		return (EACCES);
+	if (rc == VERR_INVALID_NAME)
+	    return (ENOENT);
+	return (RTErrConvertToErrno(rc));
+}
+
+/*
+ * utility to create strings
+ */
+static SHFLSTRING *
+sfprov_string(char *path, int *sz)
+{
+	SHFLSTRING *str;
+	int len = strlen(path);
+
+	*sz = len + 1 + sizeof (*str) - sizeof (str->String);
+	str = kmem_zalloc(*sz, KM_SLEEP);
+	str->u16Size = len + 1;
+	str->u16Length = len;
+	strcpy(str->String.utf8, path);
+	return (str);
+}
+
+sfp_connection_t *
+sfprov_connect(int version)
+{
+	/*
+	 * only one version for now, so must match
+	 */
+	int rc = -1;
+	if (version != SFPROV_VERSION)
+	{
+		cmn_err(CE_WARN, "sfprov_connect: wrong version. version=%d expected=%d\n", version, SFPROV_VERSION);
+		return NULL;
+	}
+	rc = VbglR0SfInit();
+	if (RT_SUCCESS(rc))
+	{
+		rc = VbglR0SfConnect(&vbox_client);
+		if (RT_SUCCESS(rc))
+		{
+			rc = VbglR0SfSetUtf8(&vbox_client);
+			if (RT_SUCCESS(rc))
+			{
+				return ((sfp_connection_t *)&vbox_client);
+			}
+			else
+				cmn_err(CE_WARN, "sfprov_connect: VbglR0SfSetUtf8() failed\n");
+
+			VbglR0SfDisconnect(&vbox_client);
+		}
+		else
+			cmn_err(CE_WARN, "sfprov_connect: VbglR0SfConnect() failed rc=%d\n", rc);
+		VbglR0SfTerm();
+	}
+	else
+		cmn_err(CE_WARN, "sfprov_connect: VbglR0SfInit() failed rc=%d\n", rc);
+	return (NULL);
+}
+
+void
+sfprov_disconnect(sfp_connection_t *conn)
+{
+	if (conn != (sfp_connection_t *)&vbox_client)
+		cmn_err(CE_WARN, "sfprov_disconnect: bad argument\n");
+	VbglR0SfDisconnect(&vbox_client);
+	VbglR0SfTerm();
+}
+
+
+int
+sfprov_mount(sfp_connection_t *conn, char *path, sfp_mount_t **mnt)
+{
+	sfp_mount_t *m;
+	SHFLSTRING *str;
+	int size;
+	int rc;
+
+	m = kmem_zalloc(sizeof (*m), KM_SLEEP);
+	str = sfprov_string(path, &size);
+	rc = VbglR0SfMapFolder(&vbox_client, str, &m->map);
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_mount: VbglR0SfMapFolder() failed. path=%s rc=%d\n", path, rc);
+		kmem_free(m, sizeof (*m));
+		*mnt = NULL;
+		rc = EINVAL;
+	} else {
+		*mnt = m;
+		rc = 0;
+	}
+	kmem_free(str, size);
+	return (rc);
+}
+
+int
+sfprov_unmount(sfp_mount_t *mnt)
+{
+	int rc;
+
+	rc = VbglR0SfUnmapFolder(&vbox_client, &mnt->map);
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_mount: VbglR0SfUnmapFolder() failed rc=%d\n", rc);
+		rc = EINVAL;
+	} else {
+		rc = 0;
+	}
+	kmem_free(mnt, sizeof (*mnt));
+	return (rc);
+}
+
+/*
+ * query information about a mounted file system
+ */
+int
+sfprov_get_fsinfo(sfp_mount_t *mnt, sffs_fsinfo_t *fsinfo)
+{
+	int rc;
+	SHFLVOLINFO info;
+	uint32_t bytes = sizeof(SHFLVOLINFO);
+
+	rc = VbglR0SfFsInfo(&vbox_client, &mnt->map, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME,
+			    &bytes, (SHFLDIRINFO *)&info);
+	if (RT_FAILURE(rc))
+		return (EINVAL);
+
+	fsinfo->blksize = info.ulBytesPerAllocationUnit;
+	fsinfo->blksused = (info.ullTotalAllocationBytes - info.ullAvailableAllocationBytes) / info.ulBytesPerAllocationUnit;
+	fsinfo->blksavail = info.ullAvailableAllocationBytes / info.ulBytesPerAllocationUnit;
+	fsinfo->maxnamesize = info.fsProperties.cbMaxComponent;
+	fsinfo->readonly = info.fsProperties.fReadOnly;
+	return (0);
+}
+
+/*
+ * file/directory information conversions.
+ */
+static void
+sfprov_fmode_from_mode(RTFMODE *fMode, mode_t mode)
+{
+	RTFMODE m = 0;
+
+#define mode_set(r) ((mode) & (S_##r)) ? RTFS_UNIX_##r : 0
+	m  = mode_set (ISUID);
+	m |= mode_set (ISGID);
+	m |= (mode & S_ISVTX) ? RTFS_UNIX_ISTXT : 0;
+
+	m |= mode_set (IRUSR);
+	m |= mode_set (IWUSR);
+	m |= mode_set (IXUSR);
+
+	m |= mode_set (IRGRP);
+	m |= mode_set (IWGRP);
+	m |= mode_set (IXGRP);
+
+	m |= mode_set (IROTH);
+	m |= mode_set (IWOTH);
+	m |= mode_set (IXOTH);
+#undef mode_set
+
+	if (S_ISDIR(mode))
+		m |= RTFS_TYPE_DIRECTORY;
+	else if (S_ISREG(mode))
+		m |= RTFS_TYPE_FILE;
+	else if (S_ISFIFO(mode))
+		m |= RTFS_TYPE_FIFO;
+	else if (S_ISCHR(mode))
+		m |= RTFS_TYPE_DEV_CHAR;
+	else if (S_ISBLK(mode))
+		m |= RTFS_TYPE_DEV_BLOCK;
+	else if (S_ISLNK(mode))
+		m |= RTFS_TYPE_SYMLINK;
+	else if (S_ISSOCK(mode))
+		m |= RTFS_TYPE_SOCKET;
+	else
+		m |= RTFS_TYPE_FILE;
+
+	*fMode = m;
+}
+
+static void
+sfprov_mode_from_fmode(sfp_mount_t *mnt, mode_t *mode, RTFMODE fMode)
+{
+	mode_t m = 0;
+
+#define mode_set_from_rt(r) ((fMode) & (RTFS_UNIX_##r)) ? (S_##r) : 0;
+	m  = mode_set_from_rt(ISUID);
+	m |= mode_set_from_rt(ISGID);
+	m |= (fMode & RTFS_UNIX_ISTXT) ? S_ISVTX : 0;
+
+	m |= mode_set_from_rt(IRUSR);
+	m |= mode_set_from_rt(IWUSR);
+	m |= mode_set_from_rt(IXUSR);
+
+	m |= mode_set_from_rt(IRGRP);
+	m |= mode_set_from_rt(IWGRP);
+	m |= mode_set_from_rt(IXGRP);
+
+	m |= mode_set_from_rt(IROTH);
+	m |= mode_set_from_rt(IWOTH);
+	m |= mode_set_from_rt(IXOTH);
+#undef mode_set_from_rt
+
+	if (RTFS_IS_DIRECTORY(fMode))
+	{
+		m = mnt->sf_dmode != ~0U ? (mnt->sf_dmode & PERMMASK) : m;
+		m &= ~mnt->sf_dmask;
+		m |= S_IFDIR;
+	}
+	else
+	{
+		m = mnt->sf_fmode != ~0U ? (mnt->sf_fmode & PERMMASK) : m;
+		m &= ~mnt->sf_fmask;
+
+		if (RTFS_IS_FILE(fMode))
+			m |= S_IFREG;
+		else if (RTFS_IS_SYMLINK(fMode))
+			m |= S_IFLNK;
+		else if (RTFS_IS_FIFO(fMode))
+			m |= S_IFIFO;
+		else if (RTFS_IS_DEV_CHAR(fMode))
+			m |= S_IFCHR;
+		else if (RTFS_IS_DEV_BLOCK(fMode))
+			m |= S_IFBLK;
+		else if (RTFS_IS_SOCKET(fMode))
+			m |= S_IFSOCK;
+	}
+
+	*mode = m;
+}
+
+static void
+sfprov_ftime_from_timespec(timestruc_t *time, RTTIMESPEC *ts)
+{
+	uint64_t nanosec = RTTimeSpecGetNano(ts);
+	time->tv_sec = nanosec / UINT64_C(1000000000);
+	time->tv_nsec = nanosec % UINT64_C(1000000000);
+}
+
+static void
+sfprov_stat_from_info(sfp_mount_t *mnt, sffs_stat_t *stat, SHFLFSOBJINFO *info)
+{
+	sfprov_mode_from_fmode(mnt, &stat->sf_mode, info->Attr.fMode);
+	stat->sf_size  = info->cbObject;
+	stat->sf_alloc = info->cbAllocated;
+	sfprov_ftime_from_timespec(&stat->sf_atime, &info->AccessTime);
+	sfprov_ftime_from_timespec(&stat->sf_mtime, &info->ModificationTime);
+	sfprov_ftime_from_timespec(&stat->sf_ctime, &info->ChangeTime);
+}
+
+/*
+ * File operations: open/close/read/write/etc.
+ *
+ * open/create can return any relevant errno, however ENOENT
+ * generally means that the host file didn't exist.
+ */
+struct sfp_file {
+	SHFLHANDLE handle;
+	VBGLSFMAP map;	/**< need this again for the close operation */
+};
+
+int
+sfprov_create(
+	sfp_mount_t *mnt,
+	char *path,
+	mode_t mode,
+	sfp_file_t **fp,
+	sffs_stat_t *stat)
+{
+
+	int rc;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	int size;
+	sfp_file_t *newfp;
+
+	str = sfprov_string(path, &size);
+	parms.Handle = SHFL_HANDLE_NIL;
+	parms.Info.cbObject = 0;
+	sfprov_fmode_from_mode(&parms.Info.Attr.fMode, mode);
+	parms.CreateFlags = SHFL_CF_ACT_CREATE_IF_NEW |
+	    SHFL_CF_ACT_REPLACE_IF_EXISTS | SHFL_CF_ACCESS_READWRITE;
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+	kmem_free(str, size);
+
+	if (RT_FAILURE(rc))
+	{
+		if (rc != VERR_ACCESS_DENIED && rc != VERR_WRITE_PROTECT)
+			cmn_err(CE_WARN, "sfprov_create: VbglR0SfCreate failed! path=%s rc=%d\n", path, rc);
+		return (sfprov_vbox2errno(rc));
+	}
+	if (parms.Handle == SHFL_HANDLE_NIL) {
+		if (parms.Result == SHFL_FILE_EXISTS)
+			return (EEXIST);
+		return (ENOENT);
+	}
+	newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
+	newfp->handle = parms.Handle;
+	newfp->map = mnt->map;
+	*fp = newfp;
+	sfprov_stat_from_info(mnt, stat, &parms.Info);
+	return (0);
+}
+
+int
+sfprov_diropen(sfp_mount_t *mnt, char *path, sfp_file_t **fp)
+{
+	int rc;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	int size;
+	sfp_file_t *newfp;
+
+	bzero(&parms, sizeof(parms));
+	str = sfprov_string(path, &size);
+	parms.Handle = SHFL_HANDLE_NIL;
+	parms.Info.cbObject = 0;
+	parms.CreateFlags =   SHFL_CF_DIRECTORY
+						| SHFL_CF_ACCESS_READ
+						| SHFL_CF_ACT_OPEN_IF_EXISTS
+						| SHFL_CF_ACT_FAIL_IF_NEW;
+
+	/*
+	 * Open the host directory.
+	 */
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+
+	/*
+	 * Our VBoxFS interface here isn't very clear regarding failure and informational status.
+	 * Check the file-handle as well as the return code to make sure the operation succeeded.
+	 */
+	if (RT_FAILURE(rc)) {
+		kmem_free(str, size);
+		return (sfprov_vbox2errno(rc));
+	}
+
+	if (parms.Handle == SHFL_HANDLE_NIL) {
+		kmem_free(str, size);
+		return (ENOENT);
+	}
+
+	newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
+	newfp->handle = parms.Handle;
+	newfp->map = mnt->map;
+	*fp = newfp;
+	return (0);
+}
+
+int
+sfprov_open(sfp_mount_t *mnt, char *path, sfp_file_t **fp, int flag)
+{
+	int rc;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	int size;
+	sfp_file_t *newfp;
+
+	bzero(&parms, sizeof(parms));
+	str = sfprov_string(path, &size);
+	parms.Handle = SHFL_HANDLE_NIL;
+	parms.Info.cbObject = 0;
+
+	/*
+	 * Translate file modes.
+	 */
+	if (flag & FCREAT) {
+		parms.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
+		if (!(flag & FTRUNC))
+			parms.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+	}
+	else
+		parms.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
+
+	if (flag & FTRUNC)
+		parms.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS | SHFL_CF_ACCESS_WRITE;
+	if (flag & FWRITE)
+		parms.CreateFlags |= SHFL_CF_ACCESS_WRITE;
+	if (flag & FREAD)
+		parms.CreateFlags |= SHFL_CF_ACCESS_READ;
+    if (flag & FAPPEND)
+		parms.CreateFlags |= SHFL_CF_ACCESS_APPEND;
+
+	/*
+	 * Open/create the host file.
+	 */
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+
+	/*
+	 * Our VBoxFS interface here isn't very clear regarding failure and informational status.
+	 * Check the file-handle as well as the return code to make sure the operation succeeded.
+	 */
+	if (RT_FAILURE(rc)) {
+		kmem_free(str, size);
+		return (sfprov_vbox2errno(rc));
+	}
+
+	if (parms.Handle == SHFL_HANDLE_NIL) {
+		kmem_free(str, size);
+		return (ENOENT);
+	}
+
+	newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
+	newfp->handle = parms.Handle;
+	newfp->map = mnt->map;
+	*fp = newfp;
+	return (0);
+}
+
+int
+sfprov_close(sfp_file_t *fp)
+{
+	int rc;
+
+	rc = VbglR0SfClose(&vbox_client, &fp->map, fp->handle);
+	kmem_free(fp, sizeof(sfp_file_t));
+	return (0);
+}
+
+int
+sfprov_read(sfp_file_t *fp, char *buffer, uint64_t offset, uint32_t *numbytes)
+{
+	int rc;
+
+	rc = VbglR0SfRead(&vbox_client, &fp->map, fp->handle, offset,
+			  numbytes, (uint8_t *)buffer, 0 /*fLocked*/);
+	if (RT_FAILURE(rc))
+		return (EINVAL);
+	return (0);
+}
+
+int
+sfprov_write(sfp_file_t *fp, char *buffer, uint64_t offset, uint32_t *numbytes)
+{
+	int rc;
+
+	rc = VbglR0SfWrite(&vbox_client, &fp->map, fp->handle, offset,
+			   numbytes, (uint8_t *)buffer, 0 /*fLocked*/);
+	if (RT_FAILURE(rc))
+		return (EINVAL);
+	return (0);
+}
+
+int
+sfprov_fsync(sfp_file_t *fp)
+{
+	int rc;
+
+	rc = VbglR0SfFlush(&vbox_client, &fp->map, fp->handle);
+	if (RT_FAILURE(rc))
+		return (EIO);
+	return (0);
+}
+
+
+static int
+sfprov_getinfo(sfp_mount_t *mnt, char *path, PSHFLFSOBJINFO info)
+{
+	int rc;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	int size;
+
+	str = sfprov_string(path, &size);
+	parms.Handle = 0;
+	parms.Info.cbObject = 0;
+	parms.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+	kmem_free(str, size);
+
+	if (RT_FAILURE(rc))
+		return (EINVAL);
+	if (parms.Result != SHFL_FILE_EXISTS)
+		return (ENOENT);
+	*info = parms.Info;
+	return (0);
+}
+
+/*
+ * get information about a file (or directory)
+ */
+int
+sfprov_get_mode(sfp_mount_t *mnt, char *path, mode_t *mode)
+{
+	int rc;
+	SHFLFSOBJINFO info;
+
+	rc = sfprov_getinfo(mnt, path, &info);
+	if (rc)
+		return (rc);
+	sfprov_mode_from_fmode(mnt, mode, info.Attr.fMode);
+	return (0);
+}
+
+int
+sfprov_get_size(sfp_mount_t *mnt, char *path, uint64_t *size)
+{
+	int rc;
+	SHFLFSOBJINFO info;
+
+	rc = sfprov_getinfo(mnt, path, &info);
+	if (rc)
+		return (rc);
+	*size = info.cbObject;
+	return (0);
+}
+
+
+int
+sfprov_get_atime(sfp_mount_t *mnt, char *path, timestruc_t *time)
+{
+	int rc;
+	SHFLFSOBJINFO info;
+
+	rc = sfprov_getinfo(mnt, path, &info);
+	if (rc)
+		return (rc);
+	sfprov_ftime_from_timespec(time, &info.AccessTime);
+	return (0);
+}
+
+int
+sfprov_get_mtime(sfp_mount_t *mnt, char *path, timestruc_t *time)
+{
+	int rc;
+	SHFLFSOBJINFO info;
+
+	rc = sfprov_getinfo(mnt, path, &info);
+	if (rc)
+		return (rc);
+	sfprov_ftime_from_timespec(time, &info.ModificationTime);
+	return (0);
+}
+
+int
+sfprov_get_ctime(sfp_mount_t *mnt, char *path, timestruc_t *time)
+{
+	int rc;
+	SHFLFSOBJINFO info;
+
+	rc = sfprov_getinfo(mnt, path, &info);
+	if (rc)
+		return (rc);
+	sfprov_ftime_from_timespec(time, &info.ChangeTime);
+	return (0);
+}
+
+int
+sfprov_get_attr(sfp_mount_t *mnt, char *path, sffs_stat_t *attr)
+{
+	int rc;
+	SHFLFSOBJINFO info;
+
+	rc = sfprov_getinfo(mnt, path, &info);
+	if (rc)
+		return (rc);
+	sfprov_stat_from_info(mnt, attr, &info);
+	return (0);
+}
+
+static void
+sfprov_timespec_from_ftime(RTTIMESPEC *ts, timestruc_t time)
+{
+	uint64_t nanosec = UINT64_C(1000000000) * time.tv_sec + time.tv_nsec;
+	RTTimeSpecSetNano(ts, nanosec);
+}
+
+int
+sfprov_set_attr(
+	sfp_mount_t *mnt,
+	char *path,
+	uint_t mask,
+	mode_t mode,
+	timestruc_t atime,
+	timestruc_t mtime,
+	timestruc_t ctime)
+{
+	int rc, err;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	SHFLFSOBJINFO info;
+	uint32_t bytes;
+	int str_size;
+
+	str = sfprov_string(path, &str_size);
+	parms.Handle = 0;
+	parms.Info.cbObject = 0;
+	parms.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
+			  | SHFL_CF_ACT_FAIL_IF_NEW
+			  | SHFL_CF_ACCESS_ATTR_WRITE;
+
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_set_attr: VbglR0SfCreate(%s) failed rc=%d\n",
+		    path, rc);
+		err = EINVAL;
+		goto fail2;
+	}
+	if (parms.Result != SHFL_FILE_EXISTS) {
+		err = ENOENT;
+		goto fail1;
+	}
+
+	RT_ZERO(info);
+	if (mask & AT_MODE)
+		sfprov_fmode_from_mode(&info.Attr.fMode, mode);
+	if (mask & AT_ATIME)
+		sfprov_timespec_from_ftime(&info.AccessTime, atime);
+	if (mask & AT_MTIME)
+		sfprov_timespec_from_ftime(&info.ModificationTime, mtime);
+	if (mask & AT_CTIME)
+		sfprov_timespec_from_ftime(&info.ChangeTime, ctime);
+
+	bytes = sizeof(info);
+	rc = VbglR0SfFsInfo(&vbox_client, &mnt->map, parms.Handle, SHFL_INFO_SET | SHFL_INFO_FILE,
+			    &bytes, (SHFLDIRINFO *)&info);
+	if (RT_FAILURE(rc)) {
+		if (rc != VERR_ACCESS_DENIED && rc != VERR_WRITE_PROTECT)
+		{
+			cmn_err(CE_WARN, "sfprov_set_attr: VbglR0SfFsInfo(%s, FILE) failed rc=%d\n",
+		    path, rc);
+		}
+		err = sfprov_vbox2errno(rc);
+		goto fail1;
+	}
+
+	err = 0;
+
+fail1:
+	rc = VbglR0SfClose(&vbox_client, &mnt->map, parms.Handle);
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_set_attr: VbglR0SfClose(%s) failed rc=%d\n",
+		    path, rc);
+	}
+fail2:
+	kmem_free(str, str_size);
+	return err;
+}
+
+int
+sfprov_set_size(sfp_mount_t *mnt, char *path, uint64_t size)
+{
+	int rc, err;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	SHFLFSOBJINFO info;
+	uint32_t bytes;
+	int str_size;
+
+	str = sfprov_string(path, &str_size);
+	parms.Handle = 0;
+	parms.Info.cbObject = 0;
+	parms.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
+			  | SHFL_CF_ACT_FAIL_IF_NEW
+			  | SHFL_CF_ACCESS_WRITE;
+
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_set_size: VbglR0SfCreate(%s) failed rc=%d\n",
+		    path, rc);
+		err = EINVAL;
+		goto fail2;
+	}
+	if (parms.Result != SHFL_FILE_EXISTS) {
+		err = ENOENT;
+		goto fail1;
+	}
+
+	RT_ZERO(info);
+	info.cbObject = size;
+	bytes = sizeof(info);
+	rc = VbglR0SfFsInfo(&vbox_client, &mnt->map, parms.Handle, SHFL_INFO_SET | SHFL_INFO_SIZE,
+			    &bytes, (SHFLDIRINFO *)&info);
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_set_size: VbglR0SfFsInfo(%s, SIZE) failed rc=%d\n",
+		    path, rc);
+		err = sfprov_vbox2errno(rc);
+		goto fail1;
+	}
+
+	err = 0;
+
+fail1:
+	rc = VbglR0SfClose(&vbox_client, &mnt->map, parms.Handle);
+	if (RT_FAILURE(rc)) {
+		cmn_err(CE_WARN, "sfprov_set_size: VbglR0SfClose(%s) failed rc=%d\n",
+		    path, rc);
+	}
+fail2:
+	kmem_free(str, str_size);
+	return err;
+}
+
+/*
+ * Directory operations
+ */
+int
+sfprov_mkdir(
+	sfp_mount_t *mnt,
+	char *path,
+	mode_t mode,
+	sfp_file_t **fp,
+	sffs_stat_t *stat)
+{
+	int rc;
+	SHFLCREATEPARMS parms;
+	SHFLSTRING *str;
+	int size;
+	sfp_file_t *newfp;
+
+	str = sfprov_string(path, &size);
+	parms.Handle = SHFL_HANDLE_NIL;
+	parms.Info.cbObject = 0;
+	sfprov_fmode_from_mode(&parms.Info.Attr.fMode, mode);
+	parms.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_CREATE_IF_NEW |
+	    SHFL_CF_ACT_FAIL_IF_EXISTS | SHFL_CF_ACCESS_READ;
+	rc = VbglR0SfCreate(&vbox_client, &mnt->map, str, &parms);
+	kmem_free(str, size);
+
+	if (RT_FAILURE(rc))
+		return (sfprov_vbox2errno(rc));
+	if (parms.Handle == SHFL_HANDLE_NIL) {
+		if (parms.Result == SHFL_FILE_EXISTS)
+			return (EEXIST);
+		return (ENOENT);
+	}
+	newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
+	newfp->handle = parms.Handle;
+	newfp->map = mnt->map;
+	*fp = newfp;
+	sfprov_stat_from_info(mnt, stat, &parms.Info);
+	return (0);
+}
+
+int
+sfprov_set_show_symlinks(void)
+{
+	int rc;
+
+	rc = VbglR0SfSetSymlinks(&vbox_client);
+	if (RT_FAILURE(rc))
+		return (sfprov_vbox2errno(rc));
+
+	return (0);
+}
+
+int
+sfprov_remove(sfp_mount_t *mnt, char *path, uint_t is_link)
+{
+	int rc;
+	SHFLSTRING *str;
+	int size;
+
+	str = sfprov_string(path, &size);
+	rc = VbglR0SfRemove(&vbox_client, &mnt->map, str,
+			    SHFL_REMOVE_FILE | (is_link ? SHFL_REMOVE_SYMLINK : 0));
+	kmem_free(str, size);
+	if (RT_FAILURE(rc))
+		return (sfprov_vbox2errno(rc));
+	return (0);
+}
+
+int
+sfprov_readlink(
+	sfp_mount_t *mnt,
+	char *path,
+	char *target,
+	size_t tgt_size)
+{
+	int rc;
+	SHFLSTRING *str;
+	int size;
+
+	str = sfprov_string(path, &size);
+
+	rc = VbglR0SfReadLink(&vbox_client, &mnt->map, str, (uint32_t) tgt_size,
+	    target);
+	if (RT_FAILURE(rc))
+		rc = sfprov_vbox2errno(rc);
+
+	kmem_free(str, size);
+	return (rc);
+}
+
+int
+sfprov_symlink(
+	sfp_mount_t *mnt,
+	char *linkname,
+	char *target,
+	sffs_stat_t *stat)
+{
+	int rc;
+	SHFLSTRING *lnk, *tgt;
+	int lnk_size, tgt_size;
+	SHFLFSOBJINFO info;
+
+	lnk = sfprov_string(linkname, &lnk_size);
+	tgt = sfprov_string(target, &tgt_size);
+
+	rc = VbglR0SfSymlink(&vbox_client, &mnt->map, lnk, tgt, &info);
+	if (RT_FAILURE(rc)) {
+		rc = sfprov_vbox2errno(rc);
+		goto done;
+	}
+
+	if (stat != NULL)
+		sfprov_stat_from_info(mnt, stat, &info);
+
+done:
+	kmem_free(lnk, lnk_size);
+	kmem_free(tgt, tgt_size);
+
+	return (rc);
+}
+
+int
+sfprov_rmdir(sfp_mount_t *mnt, char *path)
+{
+	int rc;
+	SHFLSTRING *str;
+	int size;
+
+	str = sfprov_string(path, &size);
+	rc = VbglR0SfRemove(&vbox_client, &mnt->map, str, SHFL_REMOVE_DIR);
+	kmem_free(str, size);
+	if (RT_FAILURE(rc))
+		return (sfprov_vbox2errno(rc));
+	return (0);
+}
+
+int
+sfprov_rename(sfp_mount_t *mnt, char *from, char *to, uint_t is_dir)
+{
+	int rc;
+	SHFLSTRING *old, *new;
+	int old_size, new_size;
+
+	old = sfprov_string(from, &old_size);
+	new = sfprov_string(to, &new_size);
+	rc = VbglR0SfRename(&vbox_client, &mnt->map, old, new,
+			    (is_dir ? SHFL_RENAME_DIR : SHFL_RENAME_FILE) | SHFL_RENAME_REPLACE_IF_EXISTS);
+	kmem_free(old, old_size);
+	kmem_free(new, new_size);
+	if (RT_FAILURE(rc))
+		return (sfprov_vbox2errno(rc));
+	return (0);
+}
+
+
+/*
+ * Read all filenames in a directory.
+ *
+ * - success - all entries read and returned
+ * - ENOENT - Couldn't open the directory for reading
+ * - EINVAL - Internal error of some kind
+ *
+ * On successful return, *dirents points to a list of sffs_dirents_t;
+ * for each dirent, all fields except the d_ino will be set appropriately.
+ * The caller is responsible for freeing the dirents buffer.
+ */
+int
+sfprov_readdir(
+	sfp_mount_t *mnt,
+	char *path,
+	sffs_dirents_t **dirents,
+	int flag)
+{
+	int error;
+	char *cp;
+	int len;
+	SHFLSTRING *mask_str = NULL;	/* must be path with "/ *" appended */
+	int mask_size;
+	sfp_file_t *fp;
+	uint32_t infobuff_alloc = 16384;
+	SHFLDIRINFO *infobuff = NULL, *info;
+	uint32_t numbytes;
+	uint32_t nents;
+	uint32_t size;
+	off_t offset;
+	sffs_dirents_t *cur_buf;
+	struct sffs_dirent *dirent;
+	unsigned short reclen;
+	unsigned short entlen;
+
+	*dirents = NULL;
+
+	error = sfprov_diropen(mnt, path, &fp);
+	if (error != 0)
+		return (ENOENT);
+
+	/*
+	 * Allocate the first dirents buffers.
+	 */
+	*dirents = kmem_alloc(SFFS_DIRENTS_SIZE, KM_SLEEP);
+	if (*dirents == NULL) {
+		error = (ENOSPC);
+		goto done;
+	}
+	cur_buf = *dirents;
+	cur_buf->sf_next = NULL;
+	cur_buf->sf_len = 0;
+
+	/*
+	 * Create mask that VBox expects. This needs to be the directory path,
+	 * plus a "*" wildcard to get all files.
+	 */
+	len = strlen(path) + 3;
+	cp = kmem_alloc(len, KM_SLEEP);
+	if (cp == NULL) {
+		error = (ENOSPC);
+		goto done;
+	}
+	strcpy(cp, path);
+	strcat(cp, "/*");
+	mask_str = sfprov_string(cp, &mask_size);
+	kmem_free(cp, len);
+
+	/*
+	 * Now loop using VbglR0SfDirInfo
+	 */
+	infobuff = kmem_alloc(infobuff_alloc, KM_SLEEP);
+	if (infobuff == NULL) {
+		error = (ENOSPC);
+		goto done;
+	}
+
+	offset = 0;
+	for (;;) {
+		numbytes = infobuff_alloc;
+		error = VbglR0SfDirInfo(&vbox_client, &fp->map, fp->handle,
+					mask_str, 0, 0, &numbytes, infobuff, &nents);
+		switch (error) {
+
+		case VINF_SUCCESS:
+			/* fallthrough */
+		case VERR_NO_MORE_FILES:
+			break;
+
+		case VERR_NO_TRANSLATION:
+			/* XXX ??? */
+			break;
+
+		default:
+			error = sfprov_vbox2errno(error);
+			goto done;
+		}
+
+		/*
+		 * Create the dirent_t's and save the stats for each name
+		 */
+		for (info = infobuff; (char *) info < (char *) infobuff + numbytes; nents--) {
+			/* expand buffers if we need more space */
+			reclen = DIRENT64_RECLEN(strlen(info->name.String.utf8));
+			entlen = sizeof(sffs_stat_t) + reclen;
+			if (SFFS_DIRENTS_OFF + cur_buf->sf_len + entlen > SFFS_DIRENTS_SIZE) {
+				cur_buf->sf_next = kmem_alloc(SFFS_DIRENTS_SIZE, KM_SLEEP);
+				if (cur_buf->sf_next == NULL) {
+					error = ENOSPC;
+					goto done;
+				}
+				cur_buf = cur_buf->sf_next;
+				cur_buf->sf_next = NULL;
+				cur_buf->sf_len = 0;
+			}
+
+			/* create the dirent with the name, offset, and len */
+			dirent = (struct sffs_dirent *)
+			    (((char *) &cur_buf->sf_entries[0]) + cur_buf->sf_len);
+			strncpy(&dirent->sf_entry.d_name[0], info->name.String.utf8, DIRENT64_NAMELEN(reclen));
+			dirent->sf_entry.d_reclen = reclen;
+			offset += entlen;
+			dirent->sf_entry.d_off = offset;
+
+			/* save the stats */
+			sfprov_stat_from_info(mnt, &dirent->sf_stat, &info->Info);
+
+			/* next info */
+			cur_buf->sf_len += entlen;
+			size = offsetof (SHFLDIRINFO, name.String) + info->name.u16Size;
+			info = (SHFLDIRINFO *) ((uintptr_t) info + size);
+		}
+		ASSERT(nents == 0);
+		ASSERT((char *) info == (char *) infobuff + numbytes);
+
+		if (error == VERR_NO_MORE_FILES)
+			break;
+	}
+	error = 0;
+
+done:
+	if (error != 0) {
+		while (*dirents) {
+			cur_buf = (*dirents)->sf_next;
+			kmem_free(*dirents, SFFS_DIRENTS_SIZE);
+			*dirents = cur_buf;
+		}
+	}
+	if (infobuff != NULL)
+		kmem_free(infobuff, infobuff_alloc);
+	if (mask_str != NULL)
+		kmem_free(mask_str, mask_size);
+	sfprov_close(fp);
+	return (error);
+}
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.h b/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.h
new file mode 100644
index 00000000..5794c7a9
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.h
@@ -0,0 +1,190 @@
+/* $Id: vboxfs_prov.h $ */
+/** @file
+ * VirtualBox File System for Solaris Guests, provider header.
+ * Portions contributed by: Ronald.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_prov_h
+#define GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_prov_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/VBoxGuestLibSharedFolders.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * These are the provider interfaces used by sffs to access the underlying
+ * shared file system.
+ */
+#define	SFPROV_VERSION	1
+
+/*
+ * Initialization and termination.
+ * sfprov_connect() is called once before any other interfaces and returns
+ * a handle used in further calls. The argument should be SFPROV_VERSION
+ * from above. On failure it returns a NULL pointer.
+ *
+ * sfprov_disconnect() must only be called after all sf file systems have been
+ * unmounted.
+ */
+typedef struct sfp_connection sfp_connection_t;
+
+extern sfp_connection_t *sfprov_connect(int);
+extern void sfprov_disconnect(sfp_connection_t *);
+
+
+/*
+ * Mount / Unmount a shared folder.
+ *
+ * sfprov_mount() takes as input the connection pointer and the name of
+ * the shared folder. On success, it returns zero and supplies an
+ * sfp_mount_t handle. On failure it returns any relevant errno value.
+ *
+ * sfprov_unmount() unmounts the mounted file system. It returns 0 on
+ * success and any relevant errno on failure.
+ *
+ * spf_mount_t is the representation of an active mount point.
+ */
+typedef struct spf_mount_t {
+	VBGLSFMAP	map;		/**< guest<->host mapping */
+	uid_t		sf_uid;		/**< owner of the mount point */
+	gid_t		sf_gid;		/**< group of the mount point */
+	mode_t		sf_dmode;   /**< mode of all directories if != ~0U */
+	mode_t		sf_fmode;   /**< mode of all files if != ~0U */
+	mode_t		sf_dmask;   /**< mask of all directories */
+	mode_t		sf_fmask;   /**< mask of all files */
+} sfp_mount_t;
+
+extern int sfprov_mount(sfp_connection_t *, char *, sfp_mount_t **);
+extern int sfprov_unmount(sfp_mount_t *);
+
+/*
+ * query information about a mounted file system
+ */
+typedef struct sffs_fsinfo {
+	uint64_t blksize;
+	uint64_t blksused;
+	uint64_t blksavail;
+	uint32_t maxnamesize;
+	uint32_t readonly;
+} sffs_fsinfo_t;
+
+extern int sfprov_get_fsinfo(sfp_mount_t *, sffs_fsinfo_t *);
+
+/*
+ * File operations: open/close/read/write/etc.
+ *
+ * open/create can return any relevant errno, however ENOENT
+ * generally means that the host file didn't exist.
+ */
+typedef struct sffs_stat {
+	mode_t		sf_mode;
+	off_t		sf_size;
+	off_t		sf_alloc;
+	timestruc_t	sf_atime;
+	timestruc_t	sf_mtime;
+	timestruc_t	sf_ctime;
+} sffs_stat_t;
+
+typedef struct sfp_file sfp_file_t;
+
+extern int sfprov_create(sfp_mount_t *, char *path, mode_t mode,
+    sfp_file_t **fp, sffs_stat_t *stat);
+extern int sfprov_diropen(sfp_mount_t *mnt, char *path, sfp_file_t **fp);
+extern int sfprov_open(sfp_mount_t *, char *path, sfp_file_t **fp, int flag);
+extern int sfprov_close(sfp_file_t *fp);
+extern int sfprov_read(sfp_file_t *, char * buffer, uint64_t offset,
+    uint32_t *numbytes);
+extern int sfprov_write(sfp_file_t *, char * buffer, uint64_t offset,
+    uint32_t *numbytes);
+extern int sfprov_fsync(sfp_file_t *fp);
+
+
+/*
+ * get/set information about a file (or directory) using pathname
+ */
+extern int sfprov_get_mode(sfp_mount_t *, char *, mode_t *);
+extern int sfprov_get_size(sfp_mount_t *, char *, uint64_t *);
+extern int sfprov_get_atime(sfp_mount_t *, char *, timestruc_t *);
+extern int sfprov_get_mtime(sfp_mount_t *, char *, timestruc_t *);
+extern int sfprov_get_ctime(sfp_mount_t *, char *, timestruc_t *);
+extern int sfprov_get_attr(sfp_mount_t *, char *, sffs_stat_t *);
+extern int sfprov_set_attr(sfp_mount_t *, char *, uint_t, mode_t,
+   timestruc_t, timestruc_t, timestruc_t);
+extern int sfprov_set_size(sfp_mount_t *, char *, uint64_t);
+
+
+/*
+ * File/Directory operations
+ */
+extern int sfprov_remove(sfp_mount_t *, char *path, uint_t is_link);
+extern int sfprov_mkdir(sfp_mount_t *, char *path, mode_t mode,
+    sfp_file_t **fp, sffs_stat_t *stat);
+extern int sfprov_rmdir(sfp_mount_t *, char *path);
+extern int sfprov_rename(sfp_mount_t *, char *from, char *to, uint_t is_dir);
+
+
+/*
+ * Symbolic link operations
+ */
+extern int sfprov_set_show_symlinks(void);
+extern int sfprov_readlink(sfp_mount_t *, char *path, char *target,
+    size_t tgt_size);
+extern int sfprov_symlink(sfp_mount_t *, char *linkname, char *target,
+    sffs_stat_t *stat);
+
+
+/*
+ * Read directory entries.
+ */
+/*
+ * a singly linked list of buffers, each containing an array of stat's+dirent's.
+ * sf_len is length of the sf_entries array, in bytes.
+ */
+typedef struct sffs_dirents {
+	struct sffs_dirents	*sf_next;
+	len_t			sf_len;
+	struct sffs_dirent {
+		sffs_stat_t	sf_stat;
+		dirent64_t	sf_entry;	/* this is variable length */
+	}			sf_entries[1];
+} sffs_dirents_t;
+
+#define SFFS_DIRENTS_SIZE	8192
+#define SFFS_DIRENTS_OFF	(offsetof(sffs_dirents_t, sf_entries[0]))
+
+extern int sfprov_readdir(sfp_mount_t *mnt, char *path,
+	sffs_dirents_t **dirents, int flag);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* !GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_prov_h */
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.c b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.c
new file mode 100644
index 00000000..1f20ec7b
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.c
@@ -0,0 +1,631 @@
+/* $Id: vboxfs_vfs.c $ */
+/** @file
+ * VirtualBox File System for Solaris Guests, VFS implementation.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#include <VBox/log.h>
+#include <VBox/version.h>
+#include <iprt/dbg.h>
+
+#include <sys/types.h>
+#include <sys/mntent.h>
+#include <sys/param.h>
+#include <sys/modctl.h>
+#include <sys/mount.h>
+#include <sys/policy.h>
+#include <sys/atomic.h>
+#include <sys/sysmacros.h>
+#include <sys/ddi.h>
+#include <sys/sunddi.h>
+#include <sys/vfs.h>
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+# include <sys/vfs_opreg.h>
+#endif
+#include <sys/pathname.h>
+#include <sys/cmn_err.h>
+#include <sys/vmsystm.h>
+#undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
+
+#include "vboxfs_prov.h"
+#include "vboxfs_vnode.h"
+#include "vboxfs_vfs.h"
+#include "vboxfs.h"
+
+
+#define VBOXSOLQUOTE2(x)                #x
+#define VBOXSOLQUOTE(x)                 VBOXSOLQUOTE2(x)
+/** The module name. */
+#define DEVICE_NAME                     "vboxfs"
+/** The module description as seen in 'modinfo'. */
+#define DEVICE_DESC                     "VirtualBox ShrdFS"
+
+
+/*
+ * Shared Folders filesystem implementation of the Solaris VFS interfaces.
+ * Much of this is cookie cutter code for Solaris filesystem implementation.
+ */
+
+/* forward declarations */
+static int sffs_init(int fstype, char *name);
+static int sffs_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
+static int sffs_unmount(vfs_t *vfsp, int flag, cred_t *cr);
+static int sffs_root(vfs_t *vfsp, vnode_t **vpp);
+static int sffs_statvfs(vfs_t *vfsp, statvfs64_t *sbp);
+
+static mntopt_t sffs_options[] = {
+	/* Option	Cancels Opt	Arg	Flags		Data */
+	{"uid",		NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"gid",		NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"dmode",	NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"fmode",	NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"dmask",	NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"fmask",	NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"stat_ttl",	NULL,		NULL,	MO_HASVALUE,	NULL},
+	{"fsync",	NULL,		NULL,	0,	        NULL},
+	{"tag", 	NULL,		NULL,	MO_HASVALUE,	NULL}
+};
+
+static mntopts_t sffs_options_table = {
+	sizeof (sffs_options) / sizeof (mntopt_t),
+	sffs_options
+};
+
+static vfsdef_t sffs_vfsdef = {
+	VFSDEF_VERSION,
+	DEVICE_NAME,
+	sffs_init,
+	VSW_HASPROTO,
+	&sffs_options_table
+};
+
+static int sffs_fstype;
+static int sffs_major;	/* major number for device */
+
+kmutex_t sffs_minor_lock;
+int sffs_minor;		/* minor number for device */
+
+/** Whether to use the old-style map_addr()/choose_addr() routines. */
+bool                     g_fVBoxVFS_SolOldAddrMap;
+/** The map_addr()/choose_addr() hooks callout table structure. */
+VBoxVFS_SolAddrMap       g_VBoxVFS_SolAddrMap;
+
+/*
+ * Module linkage information
+ */
+static struct modlfs modlfs = {
+	&mod_fsops,
+	DEVICE_DESC " " VBOX_VERSION_STRING "r" VBOXSOLQUOTE(VBOX_SVN_REV),
+	&sffs_vfsdef
+};
+
+static struct modlinkage modlinkage = {
+	MODREV_1, &modlfs, NULL
+};
+
+static sfp_connection_t *sfprov = NULL;
+
+int
+_init()
+{
+    RTDBGKRNLINFO hKrnlDbgInfo;
+    int rc = RTR0DbgKrnlInfoOpen(&hKrnlDbgInfo, 0 /* fFlags */);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlDbgInfo, NULL /* pszModule */, "plat_map_align_amount",  NULL /* ppvSymbol */);
+        if (RT_SUCCESS(rc))
+        {
+#if defined(VBOX_VFS_SOLARIS_10U6)
+            g_VBoxVFS_SolAddrMap.MapAddr.pfnSol_map_addr    = (void *)map_addr;
+#else
+            g_VBoxVFS_SolAddrMap.ChooseAddr.pfnSol_choose_addr = (void *)choose_addr;
+#endif
+        }
+        else
+        {
+            g_fVBoxVFS_SolOldAddrMap = true;
+#if defined(VBOX_VFS_SOLARIS_10U6)
+            g_VBoxVFS_SolAddrMap.MapAddr.pfnSol_map_addr_old    = (void *)map_addr;
+#else
+            g_VBoxVFS_SolAddrMap.ChooseAddr.pfnSol_choose_addr_old = (void *)choose_addr;
+#endif
+        }
+
+        RTR0DbgKrnlInfoRelease(hKrnlDbgInfo);
+    }
+    else
+    {
+        cmn_err(CE_NOTE, "RTR0DbgKrnlInfoOpen failed. rc=%d\n", rc);
+        return rc;
+    }
+
+	return (mod_install(&modlinkage));
+}
+
+int
+_info(struct modinfo *modinfop)
+{
+	return (mod_info(&modlinkage, modinfop));
+}
+
+
+int
+_fini()
+{
+	int error;
+
+	error = mod_remove(&modlinkage);
+	if (error)
+		return (error);
+
+	/*
+	 * Tear down the operations vectors
+	 */
+	sffs_vnode_fini();
+	(void) vfs_freevfsops_by_type(sffs_fstype);
+
+	/*
+	 * close connection to the provider
+	 */
+	sfprov_disconnect(sfprov);
+	return (0);
+}
+
+
+static int
+sffs_init(int fstype, char *name)
+{
+#if defined(VBOX_VFS_SOLARIS_10U6)
+	static const fs_operation_def_t sffs_vfsops_template[] = {
+		VFSNAME_MOUNT,		sffs_mount,
+		VFSNAME_UNMOUNT,	sffs_unmount,
+		VFSNAME_ROOT,		sffs_root,
+		VFSNAME_STATVFS,	sffs_statvfs,
+		NULL,			NULL
+	};
+#else
+	static const fs_operation_def_t sffs_vfsops_template[] = {
+		VFSNAME_MOUNT,		{ .vfs_mount = sffs_mount },
+		VFSNAME_UNMOUNT,	{ .vfs_unmount = sffs_unmount },
+		VFSNAME_ROOT,		{ .vfs_root = sffs_root },
+		VFSNAME_STATVFS,	{ .vfs_statvfs = sffs_statvfs },
+		NULL,			NULL
+	};
+#endif
+	int error;
+
+	ASSERT(fstype != 0);
+	sffs_fstype = fstype;
+	LogFlowFunc(("sffs_init() name=%s\n", name));
+
+	/*
+	 * This may seem a silly way to do things for now. But the code
+	 * is structured to easily allow it to be used on other hypervisors
+	 * which would have a different implementation of the provider.
+	 * Hopefully that'll never happen. :)
+	 */
+	sfprov = sfprov_connect(SFPROV_VERSION);
+	if (sfprov == NULL) {
+		cmn_err(CE_WARN, "sffs_init: couldn't init sffs provider");
+		return (ENODEV);
+	}
+
+	error = sfprov_set_show_symlinks();
+	if (error != 0) {
+		cmn_err(CE_WARN,  "sffs_init: host unable to show symlinks, "
+						  "rc=%d\n", error);
+	}
+
+	error = vfs_setfsops(fstype, sffs_vfsops_template, NULL);
+	if (error != 0) {
+		cmn_err(CE_WARN, "sffs_init: bad vfs ops template");
+		return (error);
+	}
+
+	error = sffs_vnode_init();
+	if (error != 0) {
+		(void) vfs_freevfsops_by_type(fstype);
+		cmn_err(CE_WARN, "sffs_init: bad vnode ops template");
+		return (error);
+	}
+
+	if ((sffs_major = getudev()) == (major_t)-1) {
+		cmn_err(CE_WARN, "sffs_init: Can't get unique device number.");
+		sffs_major = 0;
+	}
+	mutex_init(&sffs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
+	return (0);
+}
+
+/*
+ * wrapper for pn_get
+ */
+static int
+sf_pn_get(char *rawpath, struct mounta *uap, char **outpath)
+{
+	pathname_t path;
+	int error;
+
+	error = pn_get(rawpath, (uap->flags & MS_SYSSPACE) ? UIO_SYSSPACE :
+	    UIO_USERSPACE, &path);
+	if (error) {
+		LogFlowFunc(("pn_get(%s) failed\n", rawpath));
+		return (error);
+	}
+	*outpath = kmem_alloc(path.pn_pathlen + 1, KM_SLEEP);
+	strcpy(*outpath, path.pn_path);
+	pn_free(&path);
+	return (0);
+}
+
+#ifdef DEBUG_ramshankar
+static void
+sffs_print(sffs_data_t *sffs)
+{
+	cmn_err(CE_NOTE, "sffs_data_t at 0x%p\n", sffs);
+	cmn_err(CE_NOTE, "    vfs_t *sf_vfsp = 0x%p\n", sffs->sf_vfsp);
+	cmn_err(CE_NOTE, "    vnode_t *sf_rootnode = 0x%p\n", sffs->sf_rootnode);
+	cmn_err(CE_NOTE, "    uid_t sf_uid = 0x%lu\n", (ulong_t)sffs->sf_handle->sf_uid);
+	cmn_err(CE_NOTE, "    gid_t sf_gid = 0x%lu\n", (ulong_t)sffs->sf_handle->sf_gid);
+	cmn_err(CE_NOTE, "    mode_t sf_dmode = 0x%lu\n", (ulong_t)sffs->sf_handle->sf_dmode);
+	cmn_err(CE_NOTE, "    mode_t sf_fmode = 0x%lu\n", (ulong_t)sffs->sf_handle->sf_fmode);
+	cmn_err(CE_NOTE, "    mode_t sf_dmask = 0x%lu\n", (ulong_t)sffs->sf_handle->sf_dmask);
+	cmn_err(CE_NOTE, "    mode_t sf_fmask = 0x%lu\n", (ulong_t)sffs->sf_handle->sf_fmask);
+	cmn_err(CE_NOTE, "    char *sf_share_name = %s\n", sffs->sf_share_name);
+	cmn_err(CE_NOTE, "    char *sf_mntpath = %s\n", sffs->sf_mntpath);
+	cmn_err(CE_NOTE, "    sfp_mount_t *sf_handle = 0x%p\n", sffs->sf_handle);
+}
+#endif
+
+static int
+sffs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
+{
+	sffs_data_t *sffs;
+	char *mount_point = NULL;
+	char *share_name = NULL;
+	int error;
+	dev_t dev;
+	uid_t uid = 0;
+	gid_t gid = 0;
+	mode_t dmode = ~0U;
+	mode_t fmode = ~0U;
+	mode_t dmask = 0;
+	mode_t fmask = 0;
+	int stat_ttl = DEF_STAT_TTL_MS;
+	int fsync = 0;
+	char *optval;
+	long val;
+	char *path;
+	sfp_mount_t *handle;
+	sfnode_t *sfnode;
+
+	/*
+	 * check we have permission to do the mount
+	 */
+	LogFlowFunc(("sffs_mount() started\n"));
+	error = secpolicy_fs_mount(cr, mvp, vfsp);
+	if (error != 0)
+		return (error);
+
+	/*
+	 * Mount point must be a directory
+	 */
+	if (mvp->v_type != VDIR)
+		return (ENOTDIR);
+
+	/*
+	 * no support for remount (what is it?)
+	 */
+	if (uap->flags & MS_REMOUNT)
+		return (ENOTSUP);
+
+	/*
+	 * Ensure that nothing else is actively in/under the mount point
+	 */
+	mutex_enter(&mvp->v_lock);
+	if ((uap->flags & MS_OVERLAY) == 0 &&
+	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
+		mutex_exit(&mvp->v_lock);
+		return (EBUSY);
+	}
+	mutex_exit(&mvp->v_lock);
+
+	/*
+	 * check for read only has to be done early
+	 */
+	if (uap->flags & MS_RDONLY) {
+		vfsp->vfs_flag |= VFS_RDONLY;
+		vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
+	}
+
+	/*
+	 * UID to use for all files
+	 */
+	if (vfs_optionisset(vfsp, "uid", &optval) &&
+	    ddi_strtol(optval, NULL, 10, &val) == 0 &&
+	    (uid_t)val == val)
+		uid = val;
+
+	/*
+	 * GID to use for all files
+	 */
+	if (vfs_optionisset(vfsp, "gid", &optval) &&
+	    ddi_strtol(optval, NULL, 10, &val) == 0 &&
+	    (gid_t)val == val)
+		gid = val;
+
+	/*
+	 * dmode to use for all directories
+	 */
+	if (vfs_optionisset(vfsp, "dmode", &optval) &&
+		ddi_strtol(optval, NULL, 8, &val) == 0 &&
+		(mode_t)val == val)
+		dmode = val;
+
+	/*
+	 * fmode to use for all files
+	 */
+	if (vfs_optionisset(vfsp, "fmode", &optval) &&
+		ddi_strtol(optval, NULL, 8, &val) == 0 &&
+		(mode_t)val == val)
+		fmode = val;
+
+	/*
+	 * dmask to use for all directories
+	 */
+	if (vfs_optionisset(vfsp, "dmask", &optval) &&
+		ddi_strtol(optval, NULL, 8, &val) == 0 &&
+		(mode_t)val == val)
+		dmask = val;
+
+	/*
+	 * fmask to use for all files
+	 */
+	if (vfs_optionisset(vfsp, "fmask", &optval) &&
+		ddi_strtol(optval, NULL, 8, &val) == 0 &&
+		(mode_t)val == val)
+		fmask = val;
+
+	/*
+	 * umask to use for all directories & files
+	 */
+	if (vfs_optionisset(vfsp, "umask", &optval) &&
+		ddi_strtol(optval, NULL, 8, &val) == 0 &&
+		(mode_t)val == val)
+		dmask = fmask = val;
+
+	/*
+	 * ttl to use for stat caches
+	 */
+	if (vfs_optionisset(vfsp, "stat_ttl", &optval) &&
+	    ddi_strtol(optval, NULL, 10, &val) == 0 &&
+	    (int)val == val)
+	{
+		stat_ttl = val;
+	}
+	else
+		vfs_setmntopt(vfsp, "stat_ttl", VBOXSOLQUOTE(DEF_STAT_TTL_MS), 0);
+
+	/*
+	 * whether to honor fsync
+	 */
+	if (vfs_optionisset(vfsp, "fsync", &optval))
+		fsync = 1;
+
+	/*
+	 * Any unknown options are an error
+	 */
+	if ((uap->flags & MS_DATA) && uap->datalen > 0) {
+		cmn_err(CE_WARN, "sffs: unknown mount options specified");
+		return (EINVAL);
+	}
+
+	/*
+	 * get the mount point pathname
+	 */
+	error = sf_pn_get(uap->dir, uap, &mount_point);
+	if (error)
+		return (error);
+
+	/*
+	 * find what we are mounting
+	 */
+	error = sf_pn_get(uap->spec, uap, &share_name);
+	if (error) {
+		kmem_free(mount_point, strlen(mount_point) + 1);
+		return (error);
+	}
+
+	/*
+	 * Invoke Hypervisor mount interface before proceeding
+	 */
+	error = sfprov_mount(sfprov, share_name, &handle);
+	if (error) {
+		kmem_free(share_name, strlen(share_name) + 1);
+		kmem_free(mount_point, strlen(mount_point) + 1);
+		return (error);
+	}
+
+	/*
+	 * find an available minor device number for this mount
+	 */
+	mutex_enter(&sffs_minor_lock);
+	do {
+		sffs_minor = (sffs_minor + 1) & L_MAXMIN32;
+		dev = makedevice(sffs_major, sffs_minor);
+	} while (vfs_devismounted(dev));
+	mutex_exit(&sffs_minor_lock);
+
+	/*
+	 * allocate and fill in the sffs structure
+	 */
+	sffs = kmem_alloc(sizeof (*sffs), KM_SLEEP);
+	sffs->sf_vfsp = vfsp;
+	sffs->sf_handle = handle;
+	sffs->sf_handle->sf_uid = uid;
+	sffs->sf_handle->sf_gid = gid;
+	sffs->sf_handle->sf_dmode = dmode;
+	sffs->sf_handle->sf_fmode = fmode;
+	sffs->sf_handle->sf_dmask = dmask;
+	sffs->sf_handle->sf_fmask = fmask;
+	sffs->sf_stat_ttl = stat_ttl;
+	sffs->sf_fsync = fsync;
+	sffs->sf_share_name = share_name;
+	sffs->sf_mntpath = mount_point;
+	sffs->sf_ino = 3;	/* root mount point is always '3' */
+
+	/*
+	 * fill in the vfs structure
+	 */
+	vfsp->vfs_data = (caddr_t)sffs;
+	vfsp->vfs_fstype = sffs_fstype;
+	vfsp->vfs_dev = dev;
+	vfsp->vfs_bsize = PAGESIZE; /* HERE JOE ??? */
+	vfsp->vfs_flag |= VFS_NOTRUNC; /* HERE JOE ???? */
+	vfs_make_fsid(&vfsp->vfs_fsid, dev, sffs_fstype);
+
+	/*
+	 * create the root vnode.
+	 * XXX JOE What should the path be here? is "/" really right?
+	 * other options?
+	 */
+	path = kmem_alloc(2, KM_SLEEP);
+	strcpy(path, ".");
+	mutex_enter(&sffs_lock);
+	sfnode = sfnode_make(sffs, path, VDIR, NULL, NULL, NULL, 0);
+	sffs->sf_rootnode = sfnode_get_vnode(sfnode);
+	sffs->sf_rootnode->v_flag |= VROOT;
+	sffs->sf_rootnode->v_vfsp = vfsp;
+	mutex_exit(&sffs_lock);
+
+	LogFlowFunc(("sffs_mount() success sffs=0x%p\n", sffs));
+#ifdef DEBUG_ramshankar
+	sffs_print(sffs);
+#endif
+	return (error);
+}
+
+static int
+sffs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
+{
+	sffs_data_t *sffs = (sffs_data_t *)vfsp->vfs_data;
+	int error;
+
+	/*
+	 * generic security check
+	 */
+	LogFlowFunc(("sffs_unmount() of sffs=0x%p\n", sffs));
+	if ((error = secpolicy_fs_unmount(cr, vfsp)) != 0)
+		return (error);
+
+	/*
+	 * forced unmount is not supported by this file system
+	 * and thus, ENOTSUP, is being returned.
+	 */
+	if (flag & MS_FORCE) {
+		LogFlowFunc(("sffs_unmount(MS_FORCE) returns ENOSUP\n"));
+		return (ENOTSUP);
+	}
+
+	/*
+	 * Mark the file system unmounted.
+	 */
+	vfsp->vfs_flag |= VFS_UNMOUNTED;
+
+	/*
+	 * Make sure nothing is still in use.
+	 */
+	if (sffs_purge(sffs) != 0) {
+		vfsp->vfs_flag &= ~VFS_UNMOUNTED;
+		LogFlowFunc(("sffs_unmount() returns EBUSY\n"));
+		return (EBUSY);
+	}
+
+	/*
+	 * Invoke Hypervisor unmount interface before proceeding
+	 */
+	error = sfprov_unmount(sffs->sf_handle);
+	if (error != 0) {
+		/* TBD anything here? */
+	}
+
+	kmem_free(sffs->sf_share_name, strlen(sffs->sf_share_name) + 1);
+	kmem_free(sffs->sf_mntpath, strlen(sffs->sf_mntpath) + 1);
+	kmem_free(sffs, sizeof(*sffs));
+	LogFlowFunc(("sffs_unmount() done\n"));
+	return (0);
+}
+
+/*
+ * return the vnode for the root of the mounted file system
+ */
+static int
+sffs_root(vfs_t *vfsp, vnode_t **vpp)
+{
+	sffs_data_t *sffs = (sffs_data_t *)vfsp->vfs_data;
+	vnode_t *vp = sffs->sf_rootnode;
+
+	VN_HOLD(vp);
+	*vpp = vp;
+	return (0);
+}
+
+/*
+ * get some stats.. fake up the rest
+ */
+static int
+sffs_statvfs(vfs_t *vfsp, statvfs64_t *sbp)
+{
+	sffs_data_t *sffs = (sffs_data_t *)vfsp->vfs_data;
+	sffs_fsinfo_t fsinfo;
+	dev32_t d32;
+	int error;
+
+	bzero(sbp, sizeof(*sbp));
+	error = sfprov_get_fsinfo(sffs->sf_handle, &fsinfo);
+	if (error != 0)
+		return (error);
+
+	sbp->f_bsize = fsinfo.blksize;
+	sbp->f_frsize = fsinfo.blksize;
+
+	sbp->f_bfree = fsinfo.blksavail;
+	sbp->f_bavail = fsinfo.blksavail;
+	sbp->f_files = fsinfo.blksavail / 4; /* some kind of reasonable value */
+	sbp->f_ffree = fsinfo.blksavail / 4;
+	sbp->f_favail = fsinfo.blksavail / 4;
+
+	sbp->f_blocks = fsinfo.blksused + sbp->f_bavail;
+
+	(void) cmpldev(&d32, vfsp->vfs_dev);
+	sbp->f_fsid = d32;
+	strcpy(&sbp->f_basetype[0], "sffs");
+	sbp->f_flag |= ST_NOSUID;
+
+	if (fsinfo.readonly)
+		sbp->f_flag |= ST_RDONLY;
+
+	sbp->f_namemax = fsinfo.maxnamesize;
+	return (0);
+}
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.h b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.h
new file mode 100644
index 00000000..baf8908e
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vfs.h
@@ -0,0 +1,80 @@
+/* $Id: vboxfs_vfs.h $ */
+/** @file
+ * VirtualBox File System for Solaris Guests, VFS header.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_vfs_h
+#define GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_vfs_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Shared Folders filesystem per-mount data structure.
+ */
+typedef struct sffs_data {
+	vfs_t		*sf_vfsp;	/* filesystem's vfs struct */
+	vnode_t		*sf_rootnode;	/* of vnode of the root directory */
+	int  		sf_stat_ttl;	/* ttl for stat caches (in ms) */
+	int  		sf_fsync;	/* whether to honor fsync or not */
+	char		*sf_share_name;
+	char 		*sf_mntpath;	/* name of mount point */
+	sfp_mount_t	*sf_handle;
+	uint64_t	sf_ino;		/* per FS ino generator */
+} sffs_data_t;
+
+/*
+ * Workaround for older Solaris versions which called map_addr()/choose_addr()/
+ * map_addr_proc() with an 'alignment' argument that was removed in Solaris
+ * 11.4.
+ */
+typedef struct VBoxVFS_SolAddrMap
+{
+    union
+    {
+        void *(*pfnSol_map_addr)          (caddr_t *, size_t, offset_t, uint_t);
+        void *(*pfnSol_map_addr_old)      (caddr_t *, size_t, offset_t, int, uint_t);
+    } MapAddr;
+
+    union
+    {
+        int (*pfnSol_choose_addr)       (struct as *, caddr_t *, size_t, offset_t, uint_t);
+        int (*pfnSol_choose_addr_old)   (struct as *, caddr_t *, size_t, offset_t, int, uint_t);
+    } ChooseAddr;
+} VBoxVFS_SolAddrMap;
+typedef VBoxVFS_SolAddrMap *pVBoxVFS_SolAddrMap;
+
+extern bool                     g_fVBoxVFS_SolOldAddrMap;
+extern VBoxVFS_SolAddrMap       g_VBoxVFS_SolAddrMap;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* !GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_vfs_h */
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.c b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.c
new file mode 100644
index 00000000..e61ef38e
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.c
@@ -0,0 +1,2490 @@
+/* $Id: vboxfs_vnode.c $ */
+/** @file
+ * VirtualBox File System for Solaris Guests, vnode implementation.
+ * Portions contributed by: Ronald.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+/*
+ * Shared Folder File System is used from Solaris when run as a guest operating
+ * system on VirtualBox, though is meant to be usable with any hypervisor that
+ * can provide similar functionality. The sffs code handles all the Solaris
+ * specific semantics and relies on a provider module to actually access
+ * directories, files, etc. The provider interfaces are described in
+ * "vboxfs_prov.h" and the module implementing them is shipped as part of the
+ * VirtualBox Guest Additions for Solaris.
+ *
+ * The shared folder file system is similar to a networked file system,
+ * but with some caveats. The sffs code caches minimal information and proxies
+ * out to the provider whenever possible. Here are some things that are
+ * handled in this code and not by the proxy:
+ *
+ * - a way to open ".." from any already open directory
+ * - st_ino numbers
+ * - detecting directory changes that happened on the host.
+ *
+ * The implementation builds a cache of information for every file/directory
+ * ever accessed in all mounted sffs filesystems using sf_node structures.
+ *
+ * This information for both open or closed files can become invalid if
+ * asynchronous changes are made on the host. Solaris should not panic() in
+ * this event, but some file system operations may return unexpected errors.
+ * Information for such directories or files while they have active vnodes
+ * is removed from the regular cache and stored in a "stale" bucket until
+ * the vnode becomes completely inactive.
+ *
+ * We suppport only read-only mmap (VBOXVFS_WITH_MMAP) i.e. MAP_SHARED,
+ * MAP_PRIVATE in PROT_READ, this data caching would not be coherent with
+ * normal simultaneous read()/write() operations, nor will it be coherent
+ * with data access on the host. Writable mmap(MAP_SHARED) access is not
+ * implemented, as guaranteeing any kind of coherency with concurrent
+ * activity on the host would be near impossible with the existing
+ * interfaces.
+ *
+ * A note about locking. sffs is not a high performance file system.
+ * No fine grained locking is done. The one sffs_lock protects just about
+ * everything.
+ */
+
+#include <VBox/log.h>
+#include <iprt/asm.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mntent.h>
+#include <sys/param.h>
+#include <sys/modctl.h>
+#include <sys/mount.h>
+#include <sys/policy.h>
+#include <sys/atomic.h>
+#include <sys/sysmacros.h>
+#include <sys/ddi.h>
+#include <sys/sunddi.h>
+#include <sys/vfs.h>
+#include <sys/vmsystm.h>
+#include <vm/seg_kpm.h>
+#include <vm/pvn.h>
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+# include <sys/vfs_opreg.h>
+#endif
+#include <sys/pathname.h>
+#include <sys/dirent.h>
+#include <sys/fs_subr.h>
+#include <sys/time.h>
+#include <sys/cmn_err.h>
+#undef u /* /usr/include/sys/user.h:249:1 is where this is defined to (curproc->p_user). very cool. */
+
+#include "vboxfs_prov.h"
+#include "vboxfs_vnode.h"
+#include "vboxfs_vfs.h"
+
+/*
+ * Solaris 11u1b10 Extended Policy putback CR 7121445 removes secpolicy_vnode_access from sys/policy.h
+ */
+#ifdef VBOX_VFS_EXTENDED_POLICY
+int secpolicy_vnode_access(const cred_t *, vnode_t *, uid_t, mode_t);
+#endif
+
+#define VBOXVFS_WITH_MMAP
+
+static struct vnodeops *sffs_ops = NULL;
+
+kmutex_t sffs_lock;
+static avl_tree_t sfnodes;
+static avl_tree_t stale_sfnodes;
+
+/*
+ * For now we'll use an I/O buffer that doesn't page fault for VirtualBox
+ * to transfer data into.
+ */
+char *sffs_buffer;
+
+/*
+ * sfnode_compare() is needed for AVL tree functionality.
+ * The nodes are sorted by mounted filesystem, then path. If the
+ * nodes are stale, the node pointer itself is used to force uniqueness.
+ */
+static int
+sfnode_compare(const void *a, const void *b)
+{
+	sfnode_t *x = (sfnode_t *)a;
+	sfnode_t *y = (sfnode_t *)b;
+	int diff;
+
+	if (x->sf_is_stale) {
+		ASSERT(y->sf_is_stale);
+		diff = strcmp(x->sf_path, y->sf_path);
+		if (diff == 0)
+			diff = (uintptr_t)y - (uintptr_t)x;
+	} else {
+		ASSERT(!y->sf_is_stale);
+		diff = (uintptr_t)y->sf_sffs - (uintptr_t)x->sf_sffs;
+		if (diff == 0)
+			diff = strcmp(x->sf_path, y->sf_path);
+	}
+	if (diff < 0)
+		return (-1);
+	if (diff > 0)
+		return (1);
+	return (0);
+}
+
+/*
+ * Construct a new pathname given an sfnode plus an optional tail component.
+ * This handles ".." and "."
+ */
+static char *
+sfnode_construct_path(sfnode_t *node, char *tail)
+{
+	char *p;
+
+	if (strcmp(tail, ".") == 0 || strcmp(tail, "..") == 0)
+		panic("construct path for %s", tail);
+	p = kmem_alloc(strlen(node->sf_path) + 1 + strlen(tail) + 1, KM_SLEEP);
+	strcpy(p, node->sf_path);
+	strcat(p, "/");
+	strcat(p, tail);
+	return (p);
+}
+
+/*
+ * Clears the (cached) directory listing for the node.
+ */
+static void
+sfnode_clear_dir_list(sfnode_t *node)
+{
+	ASSERT(MUTEX_HELD(&sffs_lock));
+
+	while (node->sf_dir_list != NULL) {
+		sffs_dirents_t *next = node->sf_dir_list->sf_next;
+		kmem_free(node->sf_dir_list, SFFS_DIRENTS_SIZE);
+		node->sf_dir_list = next;
+	}
+}
+
+/*
+ * Open the provider file associated with a vnode. Holding the file open is
+ * the only way we have of trying to have a vnode continue to refer to the
+ * same host file in the host in light of the possibility of host side renames.
+ */
+static void
+sfnode_open(sfnode_t *node, int flag)
+{
+	int error;
+	sfp_file_t *fp;
+
+	if (node->sf_file != NULL)
+		return;
+	error = sfprov_open(node->sf_sffs->sf_handle, node->sf_path, &fp, flag);
+	if (error == 0)
+	{
+		node->sf_file = fp;
+		node->sf_flag = flag;
+	}
+	else
+		node->sf_flag = ~0;
+}
+
+/*
+ * get a new vnode reference for an sfnode
+ */
+vnode_t *
+sfnode_get_vnode(sfnode_t *node)
+{
+	vnode_t *vp;
+
+	if (node->sf_vnode != NULL) {
+		VN_HOLD(node->sf_vnode);
+	} else {
+		vp = vn_alloc(KM_SLEEP);
+        LogFlowFunc(("  %s gets vnode 0x%p\n", node->sf_path, vp));
+		vp->v_type = node->sf_type;
+		vp->v_vfsp = node->sf_sffs->sf_vfsp;
+		vn_setops(vp, sffs_ops);
+		vp->v_flag = VNOSWAP;
+#ifndef VBOXVFS_WITH_MMAP
+		vp->v_flag |= VNOMAP;
+#endif
+		vn_exists(vp);
+		vp->v_data = node;
+		node->sf_vnode = vp;
+	}
+	return (node->sf_vnode);
+}
+
+/*
+ * Allocate and initialize a new sfnode and assign it a vnode
+ */
+sfnode_t *
+sfnode_make(
+	sffs_data_t	*sffs,
+	char		*path,
+	vtype_t		type,
+	sfp_file_t	*fp,
+	sfnode_t	*parent,	/* can be NULL for root */
+	sffs_stat_t	*stat,
+	uint64_t	stat_time)
+{
+	sfnode_t	*node;
+	avl_index_t	where;
+
+	ASSERT(MUTEX_HELD(&sffs_lock));
+	ASSERT(path != NULL);
+
+	/*
+	 * build the sfnode
+	 */
+    LogFlowFunc(("sffs_make(%s)\n", path));
+	node = kmem_alloc(sizeof (*node), KM_SLEEP);
+	node->sf_sffs = sffs;
+	VFS_HOLD(node->sf_sffs->sf_vfsp);
+	node->sf_path = path;
+	node->sf_ino = sffs->sf_ino++;
+	node->sf_type = type;
+	node->sf_is_stale = 0;	/* never stale at creation */
+	node->sf_file = fp;
+	node->sf_flag = ~0;
+	node->sf_vnode = NULL;	/* do this before any sfnode_get_vnode() */
+	node->sf_children = 0;
+	node->sf_parent = parent;
+	if (parent)
+		++parent->sf_children;
+	node->sf_dir_list = NULL;
+	if (stat != NULL) {
+		node->sf_stat = *stat;
+		node->sf_stat_time = stat_time;
+	} else {
+		node->sf_stat_time = 0;
+	}
+
+	/*
+	 * add the new node to our cache
+	 */
+	if (avl_find(&sfnodes, node, &where) != NULL)
+		panic("sffs_create_sfnode(%s): duplicate sfnode_t", path);
+	avl_insert(&sfnodes, node, where);
+	return (node);
+}
+
+/*
+ * destroy an sfnode
+ */
+static void
+sfnode_destroy(sfnode_t *node)
+{
+	avl_index_t where;
+	avl_tree_t *tree;
+	sfnode_t *parent;
+top:
+	parent = node->sf_parent;
+	ASSERT(MUTEX_HELD(&sffs_lock));
+	ASSERT(node->sf_path != NULL);
+    LogFlowFunc(("sffs_destroy(%s)%s\n", node->sf_path, node->sf_is_stale ? " stale": ""));
+	if (node->sf_children != 0)
+		panic("sfnode_destroy(%s) has %d children", node->sf_path, node->sf_children);
+	if (node->sf_vnode != NULL)
+		panic("sfnode_destroy(%s) has active vnode", node->sf_path);
+
+	if (node->sf_is_stale)
+		tree = &stale_sfnodes;
+	else
+		tree = &sfnodes;
+	if (avl_find(tree, node, &where) == NULL)
+		panic("sfnode_destroy(%s) not found", node->sf_path);
+	avl_remove(tree, node);
+
+	VFS_RELE(node->sf_sffs->sf_vfsp);
+	sfnode_clear_dir_list(node);
+	kmem_free(node->sf_path, strlen(node->sf_path) + 1);
+	kmem_free(node, sizeof (*node));
+	if (parent != NULL) {
+		sfnode_clear_dir_list(parent);
+		if (parent->sf_children == 0)
+			panic("sfnode_destroy parent (%s) has no child", parent->sf_path);
+		--parent->sf_children;
+		if (parent->sf_children == 0 &&
+		    parent->sf_is_stale &&
+		    parent->sf_vnode == NULL) {
+			node = parent;
+			goto top;
+		}
+	}
+}
+
+/*
+ * Some sort of host operation on an sfnode has failed or it has been
+ * deleted. Mark this node and any children as stale, deleting knowledge
+ * about any which do not have active vnodes or children
+ * This also handle deleting an inactive node that was already stale.
+ */
+static void
+sfnode_make_stale(sfnode_t *node)
+{
+	sfnode_t *n;
+	int len;
+	ASSERT(MUTEX_HELD(&sffs_lock));
+	avl_index_t where;
+
+	/*
+	 * First deal with any children of a directory node.
+	 * If a directory becomes stale, anything below it becomes stale too.
+	 */
+	if (!node->sf_is_stale && node->sf_type == VDIR) {
+		len = strlen(node->sf_path);
+
+		n = node;
+		while ((n = AVL_NEXT(&sfnodes, node)) != NULL) {
+			ASSERT(!n->sf_is_stale);
+
+			/*
+			 * quit when no longer seeing children of node
+			 */
+			if (n->sf_sffs != node->sf_sffs ||
+			    strncmp(node->sf_path, n->sf_path, len) != 0 ||
+			    n->sf_path[len] != '/')
+				break;
+
+			/*
+			 * Either mark the child as stale or destroy it
+			 */
+			if (n->sf_vnode == NULL && n->sf_children == 0) {
+				sfnode_destroy(n);
+			} else {
+                LogFlowFunc(("sffs_make_stale(%s) sub\n", n->sf_path));
+				sfnode_clear_dir_list(n);
+				if (avl_find(&sfnodes, n, &where) == NULL)
+					panic("sfnode_make_stale(%s)"
+					    " not in sfnodes", n->sf_path);
+				avl_remove(&sfnodes, n);
+				n->sf_is_stale = 1;
+				if (avl_find(&stale_sfnodes, n, &where) != NULL)
+					panic("sffs_make_stale(%s) duplicates",
+					    n->sf_path);
+				avl_insert(&stale_sfnodes, n, where);
+			}
+		}
+	}
+
+	/*
+	 * Now deal with the given node.
+	 */
+	if (node->sf_vnode == NULL && node->sf_children == 0) {
+		sfnode_destroy(node);
+	} else if (!node->sf_is_stale) {
+        LogFlowFunc(("sffs_make_stale(%s)\n", node->sf_path));
+		sfnode_clear_dir_list(node);
+		if (node->sf_parent)
+			sfnode_clear_dir_list(node->sf_parent);
+		if (avl_find(&sfnodes, node, &where) == NULL)
+			panic("sfnode_make_stale(%s) not in sfnodes",
+			    node->sf_path);
+		avl_remove(&sfnodes, node);
+		node->sf_is_stale = 1;
+		if (avl_find(&stale_sfnodes, node, &where) != NULL)
+			panic("sffs_make_stale(%s) duplicates", node->sf_path);
+		avl_insert(&stale_sfnodes, node, where);
+	}
+}
+
+static uint64_t
+sfnode_cur_time_usec(void)
+{
+	clock_t now = drv_hztousec(ddi_get_lbolt());
+	return now;
+}
+
+static int
+sfnode_stat_cached(sfnode_t *node)
+{
+	return (sfnode_cur_time_usec() - node->sf_stat_time) <
+	    node->sf_sffs->sf_stat_ttl * 1000L;
+}
+
+static void
+sfnode_invalidate_stat_cache(sfnode_t *node)
+{
+	node->sf_stat_time = 0;
+}
+
+static int
+sfnode_update_stat_cache(sfnode_t *node)
+{
+	int error;
+
+	error = sfprov_get_attr(node->sf_sffs->sf_handle, node->sf_path,
+	    &node->sf_stat);
+	if (error == ENOENT)
+		sfnode_make_stale(node);
+	if (error == 0)
+		node->sf_stat_time = sfnode_cur_time_usec();
+
+	return (error);
+}
+
+/*
+ * Rename a file or a directory
+ */
+static void
+sfnode_rename(sfnode_t *node, sfnode_t *newparent, char *path)
+{
+	sfnode_t *n;
+	sfnode_t template;
+	avl_index_t where;
+	int len = strlen(path);
+	int old_len;
+	char *new_path;
+	char *tail;
+	ASSERT(MUTEX_HELD(&sffs_lock));
+
+	ASSERT(!node->sf_is_stale);
+
+	/*
+	 * Have to remove anything existing that had the new name.
+	 */
+	template.sf_sffs = node->sf_sffs;
+	template.sf_path = path;
+	template.sf_is_stale = 0;
+	n = avl_find(&sfnodes, &template, &where);
+	if (n != NULL)
+		sfnode_make_stale(n);
+
+	/*
+	 * Do the renaming, deal with any children of this node first.
+	 */
+	if (node->sf_type == VDIR) {
+		old_len = strlen(node->sf_path);
+		while ((n = AVL_NEXT(&sfnodes, node)) != NULL) {
+
+			/*
+			 * quit when no longer seeing children of node
+			 */
+			if (n->sf_sffs != node->sf_sffs ||
+			    strncmp(node->sf_path, n->sf_path, old_len) != 0 ||
+			    n->sf_path[old_len] != '/')
+				break;
+
+			/*
+			 * Rename the child:
+			 * - build the new path name
+			 * - unlink the AVL node
+			 * - assign the new name
+			 * - re-insert the AVL name
+			 */
+			ASSERT(strlen(n->sf_path) > old_len);
+			tail = n->sf_path + old_len; /* includes initial "/" */
+			new_path = kmem_alloc(len + strlen(tail) + 1,
+			    KM_SLEEP);
+			strcpy(new_path, path);
+			strcat(new_path, tail);
+			if (avl_find(&sfnodes, n, &where) == NULL)
+				panic("sfnode_rename(%s) not in sfnodes",
+				   n->sf_path);
+			avl_remove(&sfnodes, n);
+            LogFlowFunc(("sfnode_rname(%s to %s) sub\n", n->sf_path, new_path));
+			kmem_free(n->sf_path, strlen(n->sf_path) + 1);
+			n->sf_path = new_path;
+			if (avl_find(&sfnodes, n, &where) != NULL)
+				panic("sfnode_rename(%s) duplicates",
+				    n->sf_path);
+			avl_insert(&sfnodes, n, where);
+		}
+	}
+
+	/*
+	 * Deal with the given node.
+	 */
+	if (avl_find(&sfnodes, node, &where) == NULL)
+		panic("sfnode_rename(%s) not in sfnodes", node->sf_path);
+	avl_remove(&sfnodes, node);
+    LogFlowFunc(("sfnode_rname(%s to %s)\n", node->sf_path, path));
+	kmem_free(node->sf_path, strlen(node->sf_path) + 1);
+	node->sf_path = path;
+	if (avl_find(&sfnodes, node, &where) != NULL)
+		panic("sfnode_rename(%s) duplicates", node->sf_path);
+	avl_insert(&sfnodes, node, where);
+
+	/*
+	 * change the parent
+	 */
+	if (node->sf_parent == NULL)
+		panic("sfnode_rename(%s) no parent", node->sf_path);
+	if (node->sf_parent->sf_children == 0)
+		panic("sfnode_rename(%s) parent has no child", node->sf_path);
+	sfnode_clear_dir_list(node->sf_parent);
+	sfnode_clear_dir_list(newparent);
+	--node->sf_parent->sf_children;
+	node->sf_parent = newparent;
+	++newparent->sf_children;
+}
+
+/*
+ * Look for a cached node, if not found either handle ".." or try looking
+ * via the provider. Create an entry in sfnodes if found but not cached yet.
+ * If the create flag is set, a file or directory is created. If the file
+ * already existed, an error is returned.
+ * Nodes returned from this routine always have a vnode with its ref count
+ * bumped by 1.
+ */
+static sfnode_t *
+sfnode_lookup(
+	sfnode_t *dir,
+	char *name,
+	vtype_t create,
+	mode_t c_mode,
+	sffs_stat_t *stat,
+	uint64_t stat_time,
+	int *err)
+{
+	avl_index_t	where;
+	sfnode_t	template;
+	sfnode_t	*node;
+	int		error = 0;
+	int		type;
+	char		*fullpath;
+	sfp_file_t	*fp;
+	sffs_stat_t	tmp_stat;
+
+	ASSERT(MUTEX_HELD(&sffs_lock));
+
+	if (err)
+		*err = error;
+
+	/*
+	 * handle referencing myself
+	 */
+	if (strcmp(name, "") == 0 || strcmp(name, ".") == 0)
+		return (dir);
+
+	/*
+	 * deal with parent
+	 */
+	if (strcmp(name, "..") == 0)
+		return (dir->sf_parent);
+
+	/*
+	 * Look for an existing node.
+	 */
+	fullpath = sfnode_construct_path(dir, name);
+	template.sf_sffs = dir->sf_sffs;
+	template.sf_path = fullpath;
+	template.sf_is_stale = 0;
+	node = avl_find(&sfnodes, &template, &where);
+	if (node != NULL) {
+		kmem_free(fullpath, strlen(fullpath) + 1);
+		if (create != VNON)
+			return (NULL);
+		return (node);
+	}
+
+	/*
+	 * No entry for this path currently.
+	 * Check if the file exists with the provider and get the type from
+	 * there.
+	 */
+	if (create == VREG) {
+		type = VREG;
+		stat = &tmp_stat;
+		error = sfprov_create(dir->sf_sffs->sf_handle, fullpath, c_mode,
+					&fp, stat);
+		stat_time = sfnode_cur_time_usec();
+	} else if (create == VDIR) {
+		type = VDIR;
+		stat = &tmp_stat;
+		error = sfprov_mkdir(dir->sf_sffs->sf_handle, fullpath, c_mode,
+					&fp, stat);
+		stat_time = sfnode_cur_time_usec();
+	} else {
+		mode_t m;
+		fp = NULL;
+		type = VNON;
+		if (stat == NULL) {
+			stat = &tmp_stat;
+			error = sfprov_get_attr(dir->sf_sffs->sf_handle,
+			    fullpath, stat);
+			stat_time = sfnode_cur_time_usec();
+		} else {
+			error = 0;
+		}
+		m = stat->sf_mode;
+		if (error != 0)
+			error = ENOENT;
+		else if (S_ISDIR(m))
+			type = VDIR;
+		else if (S_ISREG(m))
+			type = VREG;
+		else if (S_ISLNK(m))
+			type = VLNK;
+	}
+
+	if (err)
+		*err = error;
+
+	/*
+	 * If no errors, make a new node and return it.
+	 */
+	if (error) {
+		kmem_free(fullpath, strlen(fullpath) + 1);
+		return (NULL);
+	}
+	node = sfnode_make(dir->sf_sffs, fullpath, type, fp, dir, stat,
+	    stat_time);
+	return (node);
+}
+
+
+/*
+ * uid and gid in sffs determine owner and group for all files.
+ */
+static int
+sfnode_access(sfnode_t *node, mode_t mode, cred_t *cr)
+{
+	sffs_data_t *sffs = node->sf_sffs;
+	mode_t m;
+	int shift = 0;
+	int error;
+	vnode_t *vp;
+
+	ASSERT(MUTEX_HELD(&sffs_lock));
+
+	/*
+	 * get the mode from the cache or provider
+	 */
+	if (sfnode_stat_cached(node))
+		error = 0;
+	else
+		error = sfnode_update_stat_cache(node);
+	m = (error == 0) ? (node->sf_stat.sf_mode & MODEMASK) : 0;
+
+	/*
+	 * mask off the permissions based on uid/gid
+	 */
+	if (crgetuid(cr) != sffs->sf_handle->sf_uid) {
+		shift += 3;
+		if (groupmember(sffs->sf_handle->sf_gid, cr) == 0)
+			shift += 3;
+	}
+	mode &= ~(m << shift);
+
+	if (mode == 0) {
+		error = 0;
+	} else {
+		/** @todo r=ramshankar: This can probably be optimized by holding static vnode
+		 *  	  templates for dir/file, as it only checks the type rather than
+		 *  	  fetching/allocating the real vnode. */
+		vp = sfnode_get_vnode(node);
+		error = secpolicy_vnode_access(cr, vp, sffs->sf_handle->sf_uid, mode);
+		VN_RELE(vp);
+	}
+	return (error);
+}
+
+
+/*
+ *
+ * Everything below this point are the vnode operations used by Solaris VFS
+ */
+static int
+sffs_readdir(
+	vnode_t		*vp,
+	uio_t		*uiop,
+	cred_t		*cred,
+	int		*eofp,
+	caller_context_t *ct,
+	int		flag)
+{
+	sfnode_t *dir = VN2SFN(vp);
+	sfnode_t *node;
+	struct sffs_dirent *dirent = NULL;
+	sffs_dirents_t *cur_buf;
+	offset_t offset = 0;
+	offset_t orig_off = uiop->uio_loffset;
+	int dummy_eof;
+	int error = 0;
+
+	if (uiop->uio_iovcnt != 1)
+		return (EINVAL);
+
+	if (vp->v_type != VDIR)
+		return (ENOTDIR);
+
+	if (eofp == NULL)
+		eofp = &dummy_eof;
+	*eofp = 0;
+
+	if (uiop->uio_loffset >= MAXOFFSET_T) {
+		*eofp = 1;
+		return (0);
+	}
+
+	/*
+	 * Get the directory entry names from the host. This gets all
+	 * entries. These are stored in a linked list of sffs_dirents_t
+	 * buffers, each of which contains a list of dirent64_t's.
+	 */
+	mutex_enter(&sffs_lock);
+
+	if (dir->sf_dir_list == NULL) {
+		error = sfprov_readdir(dir->sf_sffs->sf_handle, dir->sf_path,
+		    &dir->sf_dir_list, flag);
+		if (error != 0)
+			goto done;
+	}
+
+ 	/*
+	 * Validate and skip to the desired offset.
+	 */
+	cur_buf = dir->sf_dir_list;
+	offset = 0;
+
+	while (cur_buf != NULL &&
+	    offset + cur_buf->sf_len <= uiop->uio_loffset) {
+		offset += cur_buf->sf_len;
+		cur_buf = cur_buf->sf_next;
+	}
+
+	if (cur_buf == NULL && offset != uiop->uio_loffset) {
+		error = EINVAL;
+		goto done;
+	}
+	if (cur_buf != NULL && offset != uiop->uio_loffset) {
+		offset_t off = offset;
+		int step;
+		dirent = &cur_buf->sf_entries[0];
+
+		while (off < uiop->uio_loffset) {
+			if (dirent->sf_entry.d_off == uiop->uio_loffset)
+				break;
+			step = sizeof(sffs_stat_t) + dirent->sf_entry.d_reclen;
+			dirent = (struct sffs_dirent *) (((char *) dirent) + step);
+			off += step;
+		}
+
+		if (off >= uiop->uio_loffset) {
+			error = EINVAL;
+			goto done;
+		}
+	}
+
+	offset = uiop->uio_loffset - offset;
+
+	/*
+	 * Lookup each of the names, so that we have ino's, and copy to
+	 * result buffer.
+	 */
+	while (cur_buf != NULL) {
+		if (offset >= cur_buf->sf_len) {
+			cur_buf = cur_buf->sf_next;
+			offset = 0;
+			continue;
+		}
+
+		dirent = (struct sffs_dirent *)
+		    (((char *) &cur_buf->sf_entries[0]) + offset);
+		if (dirent->sf_entry.d_reclen > uiop->uio_resid)
+			break;
+
+		if (strcmp(dirent->sf_entry.d_name, ".") == 0) {
+			node = dir;
+		} else if (strcmp(dirent->sf_entry.d_name, "..") == 0) {
+			node = dir->sf_parent;
+			if (node == NULL)
+				node = dir;
+		} else {
+			node = sfnode_lookup(dir, dirent->sf_entry.d_name, VNON,
+				0, &dirent->sf_stat, sfnode_cur_time_usec(), NULL);
+			if (node == NULL)
+				panic("sffs_readdir() lookup failed");
+		}
+		dirent->sf_entry.d_ino = node->sf_ino;
+
+		error = uiomove(&dirent->sf_entry, dirent->sf_entry.d_reclen, UIO_READ, uiop);
+		if (error != 0)
+			break;
+
+		uiop->uio_loffset= dirent->sf_entry.d_off;
+		offset += sizeof(sffs_stat_t) + dirent->sf_entry.d_reclen;
+	}
+	if (error == 0 && cur_buf == NULL)
+		*eofp = 1;
+done:
+	mutex_exit(&sffs_lock);
+	if (error != 0)
+		uiop->uio_loffset = orig_off;
+	return (error);
+}
+
+
+#if defined(VBOX_VFS_SOLARIS_10U6)
+/*
+ * HERE JOE.. this may need more logic, need to look at other file systems
+ */
+static int
+sffs_pathconf(
+	vnode_t	*vp,
+	int	cmd,
+	ulong_t	*valp,
+	cred_t	*cr)
+{
+	return (fs_pathconf(vp, cmd, valp, cr));
+}
+#else
+/*
+ * HERE JOE.. this may need more logic, need to look at other file systems
+ */
+static int
+sffs_pathconf(
+	vnode_t	*vp,
+	int	cmd,
+	ulong_t	*valp,
+	cred_t	*cr,
+	caller_context_t *ct)
+{
+	return (fs_pathconf(vp, cmd, valp, cr, ct));
+}
+#endif
+
+static int
+sffs_getattr(
+	vnode_t		*vp,
+	vattr_t		*vap,
+	int		flags,
+	cred_t		*cred,
+	caller_context_t *ct)
+{
+	sfnode_t	*node = VN2SFN(vp);
+	sffs_data_t	*sffs = node->sf_sffs;
+	mode_t		mode;
+	int		error = 0;
+
+	mutex_enter(&sffs_lock);
+	vap->va_type = vp->v_type;
+	vap->va_uid = sffs->sf_handle->sf_uid;
+	vap->va_gid = sffs->sf_handle->sf_gid;
+	vap->va_fsid = sffs->sf_vfsp->vfs_dev;
+	vap->va_nodeid = node->sf_ino;
+	vap->va_nlink = 1;
+	vap->va_rdev =  sffs->sf_vfsp->vfs_dev;
+	vap->va_seq = 0;
+
+	if (!sfnode_stat_cached(node)) {
+		error = sfnode_update_stat_cache(node);
+		if (error != 0)
+			goto done;
+	}
+
+	vap->va_atime = node->sf_stat.sf_atime;
+	vap->va_mtime = node->sf_stat.sf_mtime;
+	vap->va_ctime = node->sf_stat.sf_ctime;
+
+	mode = node->sf_stat.sf_mode;
+	vap->va_mode = mode & MODEMASK;
+
+	vap->va_size = node->sf_stat.sf_size;
+	vap->va_blksize = 512;
+	vap->va_nblocks = (node->sf_stat.sf_alloc + 511) / 512;
+
+done:
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+static int
+sffs_setattr(
+	vnode_t		*vp,
+	vattr_t		*vap,
+	int		flags,
+	cred_t		*cred,
+	caller_context_t *ct)
+{
+	sfnode_t	*node = VN2SFN(vp);
+	int		error;
+	mode_t		mode;
+
+	mode = vap->va_mode;
+	if (vp->v_type == VREG)
+		mode |= S_IFREG;
+	else if (vp->v_type == VDIR)
+		mode |= S_IFDIR;
+	else if (vp->v_type == VBLK)
+		mode |= S_IFBLK;
+	else if (vp->v_type == VCHR)
+		mode |= S_IFCHR;
+	else if (vp->v_type == VLNK)
+		mode |= S_IFLNK;
+	else if (vp->v_type == VFIFO)
+		mode |= S_IFIFO;
+	else if (vp->v_type == VSOCK)
+		mode |= S_IFSOCK;
+
+	mutex_enter(&sffs_lock);
+
+	sfnode_invalidate_stat_cache(node);
+	error = sfprov_set_attr(node->sf_sffs->sf_handle, node->sf_path,
+	    vap->va_mask, mode, vap->va_atime, vap->va_mtime, vap->va_ctime);
+	if (error == ENOENT)
+		sfnode_make_stale(node);
+
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+static int
+sffs_space(
+	vnode_t		*vp,
+	int		cmd,
+	struct flock64	*bfp,
+	int		flags,
+	offset_t	off,
+	cred_t		*cred,
+	caller_context_t *ct)
+{
+	sfnode_t	*node = VN2SFN(vp);
+	int		error;
+
+	/* we only support changing the length of the file */
+	if (bfp->l_whence != SEEK_SET || bfp->l_len != 0)
+		return ENOSYS;
+
+	mutex_enter(&sffs_lock);
+
+	sfnode_invalidate_stat_cache(node);
+
+	error = sfprov_set_size(node->sf_sffs->sf_handle, node->sf_path,
+	    bfp->l_start);
+	if (error == ENOENT)
+		sfnode_make_stale(node);
+
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+/*ARGSUSED*/
+static int
+sffs_read(
+	vnode_t		*vp,
+	struct uio	*uio,
+	int		ioflag,
+	cred_t		*cred,
+	caller_context_t *ct)
+{
+	sfnode_t	*node = VN2SFN(vp);
+	int		error = 0;
+	uint32_t	bytes;
+	uint32_t	done;
+	ulong_t 	offset;
+	ssize_t		total;
+
+	if (vp->v_type == VDIR)
+		return (EISDIR);
+	if (vp->v_type != VREG)
+		return (EINVAL);
+	if (uio->uio_loffset >= MAXOFFSET_T)
+		return (0);
+	if (uio->uio_loffset < 0)
+		return (EINVAL);
+	total = uio->uio_resid;
+	if (total == 0)
+		return (0);
+
+	mutex_enter(&sffs_lock);
+	if (node->sf_file == NULL) {
+		ASSERT(node->sf_flag != ~0);
+		sfnode_open(node, node->sf_flag);
+		if (node->sf_file == NULL)
+			return (EBADF);
+	}
+
+	do {
+		offset = uio->uio_offset;
+		done = bytes = MIN(PAGESIZE, uio->uio_resid);
+		error = sfprov_read(node->sf_file, sffs_buffer, offset, &done);
+		if (error == 0 && done > 0)
+			error = uiomove(sffs_buffer, done, UIO_READ, uio);
+	} while (error == 0 && uio->uio_resid > 0 && done > 0);
+
+	mutex_exit(&sffs_lock);
+
+	/*
+	 * a partial read is never an error
+	 */
+	if (total != uio->uio_resid)
+		error = 0;
+	return (error);
+}
+
+/*ARGSUSED*/
+static int
+sffs_write(
+	vnode_t		*vp,
+	struct uio	*uiop,
+	int		ioflag,
+	cred_t		*cred,
+	caller_context_t *ct)
+{
+	sfnode_t	*node = VN2SFN(vp);
+	int		error = 0;
+	uint32_t	bytes;
+	uint32_t	done;
+	ulong_t 	offset;
+	ssize_t		total;
+	rlim64_t	limit = uiop->uio_llimit;
+
+	if (vp->v_type == VDIR)
+		return (EISDIR);
+	if (vp->v_type != VREG)
+		return (EINVAL);
+
+	/*
+	 * We have to hold this lock for a long time to keep
+	 * multiple FAPPEND writes from intermixing
+	 */
+	mutex_enter(&sffs_lock);
+	if (node->sf_file == NULL) {
+		ASSERT(node->sf_flag != ~0);
+		sfnode_open(node, node->sf_flag);
+		if (node->sf_file == NULL)
+			return (EBADF);
+	}
+
+	sfnode_invalidate_stat_cache(node);
+
+	if (ioflag & FAPPEND) {
+		uint64_t endoffile;
+
+		error = sfprov_get_size(node->sf_sffs->sf_handle,
+		    node->sf_path, &endoffile);
+		if (error == ENOENT)
+			sfnode_make_stale(node);
+		if (error != 0) {
+			mutex_exit(&sffs_lock);
+			return (error);
+		}
+		uiop->uio_loffset = endoffile;
+	}
+
+	if (vp->v_type != VREG || uiop->uio_loffset < 0) {
+		mutex_exit(&sffs_lock);
+		return (EINVAL);
+	}
+	if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T)
+		limit = MAXOFFSET_T;
+
+	if (uiop->uio_loffset >= limit) {
+		mutex_exit(&sffs_lock);
+		return (EFBIG);
+	}
+
+	if (uiop->uio_loffset >= MAXOFFSET_T) {
+		mutex_exit(&sffs_lock);
+		return (EFBIG);
+	}
+
+	total = uiop->uio_resid;
+	if (total == 0) {
+		mutex_exit(&sffs_lock);
+   		return (0);
+	}
+
+	do {
+		offset = uiop->uio_offset;
+		bytes = MIN(PAGESIZE, uiop->uio_resid);
+		if (offset + bytes >= limit) {
+			if (offset >= limit) {
+				error = EFBIG;
+				break;
+			}
+			bytes = limit - offset;
+		}
+		error = uiomove(sffs_buffer, bytes, UIO_WRITE, uiop);
+		if (error != 0)
+			break;
+		done = bytes;
+		if (error == 0)
+			error = sfprov_write(node->sf_file, sffs_buffer,
+			    offset, &done);
+		total -= done;
+		if (done != bytes) {
+			uiop->uio_resid += bytes - done;
+			break;
+		}
+	} while (error == 0 && uiop->uio_resid > 0 && done > 0);
+
+	mutex_exit(&sffs_lock);
+
+	/*
+	 * A short write is never really an error.
+	 */
+	if (total != uiop->uio_resid)
+		error = 0;
+	return (error);
+}
+
+/*ARGSUSED*/
+static int
+sffs_access(vnode_t *vp, int mode, int flags, cred_t *cr, caller_context_t *ct)
+{
+	sfnode_t *node = VN2SFN(vp);
+	int error;
+
+	mutex_enter(&sffs_lock);
+	error = sfnode_access(node, mode, cr);
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+/*
+ * Lookup an entry in a directory and create a new vnode if found.
+ */
+/* ARGSUSED3 */
+static int
+sffs_lookup(
+	vnode_t		*dvp,		/* the directory vnode */
+	char		*name,		/* the name of the file or directory */
+	vnode_t		**vpp,		/* the vnode we found or NULL */
+	struct pathname	*pnp,
+	int		flags,
+	vnode_t		*rdir,
+	cred_t		*cred,
+	caller_context_t *ct,
+	int		*direntflags,
+	struct pathname	*realpnp)
+{
+	int		error;
+	sfnode_t	*node;
+
+	/*
+	 * dvp must be a directory
+	 */
+	if (dvp->v_type != VDIR)
+		return (ENOTDIR);
+
+	/*
+	 * An empty component name or just "." means the directory itself.
+	 * Don't do any further lookup or checking.
+	 */
+	if (strcmp(name, "") == 0 || strcmp(name, ".") == 0) {
+		VN_HOLD(dvp);
+		*vpp = dvp;
+		return (0);
+	}
+
+	/*
+	 * Check permission to look at this directory. We always allow "..".
+	 */
+	mutex_enter(&sffs_lock);
+	if (strcmp(name, "..") != 0) {
+		error = sfnode_access(VN2SFN(dvp), VEXEC, cred);
+		if (error) {
+			mutex_exit(&sffs_lock);
+			return (error);
+		}
+	}
+
+	/*
+	 * Lookup the node.
+	 */
+	node = sfnode_lookup(VN2SFN(dvp), name, VNON, 0, NULL, 0, NULL);
+	if (node != NULL)
+		*vpp = sfnode_get_vnode(node);
+	mutex_exit(&sffs_lock);
+	return ((node == NULL) ? ENOENT : 0);
+}
+
+/*ARGSUSED*/
+static int
+sffs_create(
+        vnode_t		*dvp,
+        char		*name,
+        struct vattr	*vap,
+        vcexcl_t	exclusive,
+        int		mode,
+        vnode_t		**vpp,
+        cred_t		*cr,
+        int		flag,
+        caller_context_t *ct,
+        vsecattr_t	*vsecp)
+{
+	vnode_t		*vp;
+	sfnode_t	*node;
+	int		error;
+
+	ASSERT(name != NULL);
+
+	/*
+	 * this is used for regular files, not mkdir
+	 */
+	if (vap->va_type == VDIR)
+		return (EISDIR);
+	if (vap->va_type != VREG)
+		return (EINVAL);
+
+	/*
+	 * is this a pre-existing file?
+	 */
+	error = sffs_lookup(dvp, name, &vp,
+	    NULL, 0, NULL, cr, ct, NULL, NULL);
+	if (error == ENOENT)
+		vp = NULL;
+	else if (error != 0)
+		return (error);
+
+	/*
+	 * Operation on a pre-existing file.
+	 */
+	if (vp != NULL) {
+		if (exclusive == EXCL) {
+			VN_RELE(vp);
+			return (EEXIST);
+		}
+		if (vp->v_type == VDIR && (mode & VWRITE) == VWRITE) {
+			VN_RELE(vp);
+			return (EISDIR);
+		}
+
+		mutex_enter(&sffs_lock);
+		node = VN2SFN(vp);
+		error = sfnode_access(node, mode, cr);
+		if (error != 0) {
+			mutex_exit(&sffs_lock);
+			VN_RELE(vp);
+			return (error);
+		}
+
+		sfnode_invalidate_stat_cache(VN2SFN(dvp));
+
+		/*
+		 * handle truncating an existing file
+		 */
+		if (vp->v_type == VREG && (vap->va_mask & AT_SIZE) &&
+		    vap->va_size == 0) {
+			sfnode_open(node, flag | FTRUNC);
+			if (node->sf_path == NULL) {
+				mutex_exit(&sffs_lock);
+				VN_RELE(vp);
+				return (ENOENT);
+			}
+		}
+		mutex_exit(&sffs_lock);
+		*vpp = vp;
+		return (0);
+	}
+
+	/*
+	 * Create a new node. First check for a race creating it.
+	 */
+	mutex_enter(&sffs_lock);
+	node = sfnode_lookup(VN2SFN(dvp), name, VNON, 0, NULL, 0, NULL);
+	if (node != NULL) {
+		mutex_exit(&sffs_lock);
+		return (EEXIST);
+	}
+
+	/*
+	 * Doesn't exist yet and we have the lock, so create it.
+	 */
+	sfnode_invalidate_stat_cache(VN2SFN(dvp));
+	int lookuperr;
+	node = sfnode_lookup(VN2SFN(dvp), name, VREG,
+		(vap->va_mask & AT_MODE) ? vap->va_mode : 0, NULL, 0, &lookuperr);
+
+	if (node && node->sf_parent)
+		sfnode_clear_dir_list(node->sf_parent);
+
+	mutex_exit(&sffs_lock);
+	if (node == NULL)
+		return (lookuperr);
+	*vpp = sfnode_get_vnode(node);
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+sffs_mkdir(
+	vnode_t		*dvp,
+	char		*nm,
+	vattr_t		*va,
+	vnode_t		**vpp,
+	cred_t		*cred,
+	caller_context_t *ct,
+	int		flags,
+	vsecattr_t	*vsecp)
+{
+	sfnode_t	*node;
+	vnode_t		*vp;
+	int		error;
+
+	/*
+	 * These should never happen
+	 */
+	ASSERT(nm != NULL);
+	ASSERT(strcmp(nm, "") != 0);
+	ASSERT(strcmp(nm, ".") != 0);
+	ASSERT(strcmp(nm, "..") != 0);
+
+	/*
+	 * Do an unlocked look up first
+	 */
+	error = sffs_lookup(dvp, nm, &vp, NULL, 0, NULL, cred, ct, NULL, NULL);
+	if (error == 0) {
+		VN_RELE(vp);
+		return (EEXIST);
+	}
+	if (error != ENOENT)
+		return (error);
+
+	/*
+	 * Must be able to write in current directory
+	 */
+	mutex_enter(&sffs_lock);
+	error = sfnode_access(VN2SFN(dvp), VWRITE, cred);
+	if (error) {
+		mutex_exit(&sffs_lock);
+		return (error);
+	}
+
+	sfnode_invalidate_stat_cache(VN2SFN(dvp));
+	int lookuperr = EACCES;
+	node = sfnode_lookup(VN2SFN(dvp), nm, VDIR,
+		(va->va_mode & AT_MODE) ? va->va_mode : 0, NULL, 0, &lookuperr);
+
+	if (node && node->sf_parent)
+		sfnode_clear_dir_list(node->sf_parent);
+
+	mutex_exit(&sffs_lock);
+	if (node == NULL)
+		return (lookuperr);
+	*vpp = sfnode_get_vnode(node);
+	return (0);
+}
+
+/*ARGSUSED*/
+static int
+sffs_rmdir(
+	struct vnode	*dvp,
+	char		*nm,
+	vnode_t		*cdir,
+	cred_t		*cred,
+	caller_context_t *ct,
+	int		flags)
+{
+	sfnode_t	 *node;
+	vnode_t		*vp;
+	int		error;
+
+	/*
+	 * Return error when removing . and ..
+	 */
+	if (strcmp(nm, ".") == 0 || strcmp(nm, "") == 0)
+		return (EINVAL);
+	if (strcmp(nm, "..") == 0)
+		return (EEXIST);
+
+	error = sffs_lookup(dvp, nm, &vp, NULL, 0, NULL, cred, ct, NULL, NULL);
+	if (error)
+		return (error);
+	if (vp->v_type != VDIR) {
+		VN_RELE(vp);
+		return (ENOTDIR);
+	}
+
+#ifdef VBOXVFS_WITH_MMAP
+	if (vn_vfswlock(vp)) {
+		VN_RELE(vp);
+		return (EBUSY);
+	}
+#endif
+
+	if (vn_mountedvfs(vp)) {
+		VN_RELE(vp);
+		return (EBUSY);
+	}
+
+	node = VN2SFN(vp);
+
+	mutex_enter(&sffs_lock);
+	error = sfnode_access(VN2SFN(dvp), VEXEC | VWRITE, cred);
+	if (error)
+		goto done;
+
+	/*
+	 * If anything else is using this vnode, then fail the remove.
+	 * Why?  Windows hosts can't remove something that is open,
+	 * so we have to sfprov_close() it first.
+	 * There is no errno for this - since it's not a problem on UNIX,
+	 * but EINVAL is the closest.
+	 */
+	if (node->sf_file != NULL) {
+		if (vp->v_count > 1) {
+			error = EINVAL;
+			goto done;
+		}
+		(void)sfprov_close(node->sf_file);
+		node->sf_file = NULL;
+	}
+
+	/*
+	 * Remove the directory on the host and mark the node as stale.
+	 */
+	sfnode_invalidate_stat_cache(VN2SFN(dvp));
+	error = sfprov_rmdir(node->sf_sffs->sf_handle, node->sf_path);
+	if (error == ENOENT || error == 0)
+		sfnode_make_stale(node);
+
+	if (node->sf_parent)
+		sfnode_clear_dir_list(node->sf_parent);
+done:
+	mutex_exit(&sffs_lock);
+#ifdef VBOXVFS_WITH_MMAP
+	vn_vfsunlock(vp);
+#endif
+	VN_RELE(vp);
+	return (error);
+}
+
+
+#ifdef VBOXVFS_WITH_MMAP
+static caddr_t
+sffs_page_map(
+	page_t *ppage,
+	enum seg_rw segaccess)
+{
+	/* Use seg_kpm driver if possible (64-bit) */
+	if (kpm_enable)
+		return (hat_kpm_mapin(ppage, NULL));
+	ASSERT(segaccess == S_READ || segaccess == S_WRITE);
+	return (ppmapin(ppage, PROT_READ | ((segaccess == S_WRITE) ? PROT_WRITE : 0), (caddr_t)-1));
+}
+
+
+static void
+sffs_page_unmap(
+	page_t *ppage,
+	caddr_t addr)
+{
+	if (kpm_enable)
+		hat_kpm_mapout(ppage, NULL, addr);
+	else
+		ppmapout(addr);
+}
+
+
+/*
+ * Called when there's no page in the cache. This will create new page(s) and read
+ * the file data into it.
+ */
+static int
+sffs_readpages(
+	vnode_t		*dvp,
+	offset_t	off,
+	page_t		*pagelist[],
+	size_t		pagelistsize,
+	struct seg  *segp,
+	caddr_t		addr,
+	enum seg_rw	segaccess)
+{
+	ASSERT(MUTEX_HELD(&sffs_lock));
+
+	int error = 0;
+	u_offset_t io_off, total;
+	size_t io_len;
+	page_t *ppages;
+	page_t *pcur;
+
+	sfnode_t *node = VN2SFN(dvp);
+	ASSERT(node);
+	ASSERT(node->sf_file);
+
+	if (pagelistsize == PAGESIZE)
+	{
+		io_off = off;
+		io_len = PAGESIZE;
+		ppages = page_create_va(dvp, io_off, io_len, PG_WAIT | PG_EXCL, segp, addr);
+	}
+	else
+		ppages = pvn_read_kluster(dvp, off, segp, addr, &io_off, &io_len, off, pagelistsize, 0);
+
+	/* If page already exists return success */
+	if (!ppages)
+	{
+		*pagelist = NULL;
+		return (0);
+	}
+
+	/*
+	 * Map & read page-by-page.
+	 */
+	total = io_off + io_len;
+	pcur = ppages;
+	while (io_off < total)
+	{
+		ASSERT3U(io_off, ==, pcur->p_offset);
+
+		caddr_t virtaddr = sffs_page_map(pcur, segaccess);
+		uint32_t bytes = PAGESIZE;
+		error = sfprov_read(node->sf_file, virtaddr, io_off, &bytes);
+		/*
+		 * If we reuse pages without zero'ing them, one process can mmap() and read-past the length
+		 * to read previously mmap'd contents (from possibly other processes).
+		 */
+		if (error == 0 && bytes < PAGESIZE)
+			memset(virtaddr + bytes, 0, PAGESIZE - bytes);
+		sffs_page_unmap(pcur, virtaddr);
+		if (error != 0)
+		{
+			cmn_err(CE_WARN, "sffs_readpages: sfprov_read() failed. error=%d bytes=%u\n", error, bytes);
+			/* Get rid of all kluster pages read & bail.  */
+			pvn_read_done(ppages, B_ERROR);
+			return (error);
+		}
+		pcur = pcur->p_next;
+		io_off += PAGESIZE;
+	}
+
+	/*
+	 * Fill in the pagelist from kluster at the requested offset.
+	 */
+	pvn_plist_init(ppages, pagelist, pagelistsize, off, io_len, segaccess);
+	ASSERT(pagelist == NULL || (*pagelist)->p_offset == off);
+	return (0);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_getpage(
+	vnode_t		*dvp,
+	offset_t	off,
+	size_t		len,
+	uint_t 		*protp,
+	page_t 		*pagelist[],
+	size_t		pagelistsize,
+	struct seg	*segp,
+	caddr_t 	addr,
+	enum seg_rw	segaccess,
+	cred_t		*credp
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	, caller_context_t *ct
+#endif
+	)
+{
+	int error = 0;
+	int is_recursive = 0;
+	page_t **pageliststart = pagelist;
+	sfnode_t *node = VN2SFN(dvp);
+	ASSERT(node);
+	ASSERT(node->sf_file);
+
+	if (segaccess == S_WRITE)
+		return (ENOSYS);	/* Will this ever happen? */
+
+	/* Don't bother about faultahead for now. */
+	if (pagelist == NULL)
+		return (0);
+
+	if (len > pagelistsize)
+		len = pagelistsize;
+	else
+		len = P2ROUNDUP(len, PAGESIZE);
+	ASSERT(pagelistsize >= len);
+
+	if (protp)
+		*protp = PROT_ALL;
+
+	/*
+	 * The buffer passed to sffs_write may be mmap'd so we may get a
+	 * pagefault there, in which case we'll end up here with this thread
+	 * already owning the mutex. Mutexes aren't recursive.
+	 */
+	if (mutex_owner(&sffs_lock) == curthread)
+		is_recursive = 1;
+	else
+		mutex_enter(&sffs_lock);
+
+	/* Don't map pages past end of the file. */
+	if (off + len > node->sf_stat.sf_size + PAGEOFFSET)
+	{
+		if (!is_recursive)
+			mutex_exit(&sffs_lock);
+		return (EFAULT);
+	}
+
+	while (len > 0)
+	{
+		/*
+		 * Look for pages in the requested offset range, or create them if we can't find any.
+		 */
+		if ((*pagelist = page_lookup(dvp, off, SE_SHARED)) != NULL)
+			*(pagelist + 1) = NULL;
+		else if ((error = sffs_readpages(dvp, off, pagelist, pagelistsize, segp, addr, segaccess)) != 0)
+		{
+			while (pagelist > pageliststart)
+				page_unlock(*--pagelist);
+
+			*pagelist = NULL;
+			if (!is_recursive)
+				mutex_exit(&sffs_lock);
+			return (error);
+		}
+
+		while (*pagelist)
+		{
+			ASSERT3U((*pagelist)->p_offset, ==, off);
+			off += PAGESIZE;
+			addr += PAGESIZE;
+			if (len > 0)
+			{
+				ASSERT3U(len, >=, PAGESIZE);
+				len -= PAGESIZE;
+			}
+
+			ASSERT3U(pagelistsize,  >=, PAGESIZE);
+			pagelistsize -= PAGESIZE;
+			pagelist++;
+		}
+	}
+
+	/*
+	 * Fill the page list array with any pages left in the cache.
+	 */
+	while (   pagelistsize > 0
+		   && (*pagelist++ = page_lookup_nowait(dvp, off, SE_SHARED)))
+	{
+		off += PAGESIZE;
+		pagelistsize -= PAGESIZE;
+	}
+
+	*pagelist = NULL;
+	if (!is_recursive)
+		mutex_exit(&sffs_lock);
+	return (error);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_putpage(
+	vnode_t		*dvp,
+	offset_t	off,
+	size_t		len,
+	int			flags,
+	cred_t		*credp
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	, caller_context_t *ct
+#endif
+	)
+{
+	/*
+	 * We don't support PROT_WRITE mmaps.
+	 */
+	return (ENOSYS);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_discardpage(
+	vnode_t		*dvp,
+	page_t		*ppage,
+	u_offset_t	*poff,
+	size_t		*plen,
+	int			flags,
+	cred_t		*pcred)
+{
+	/*
+	 * This would not get invoked i.e. via pvn_vplist_dirty() since we don't support
+	 * PROT_WRITE mmaps and therefore will not have dirty pages.
+	 */
+	pvn_write_done(ppage, B_INVAL | B_ERROR | B_FORCE);
+	return (0);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_map(
+	vnode_t		*dvp,
+	offset_t	off,
+	struct as 	*asp,
+	caddr_t		*addrp,
+	size_t		len,
+	uchar_t		prot,
+	uchar_t		maxprot,
+	uint_t		flags,
+	cred_t 		*credp
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	, caller_context_t *ct
+#endif
+	)
+{
+	/*
+	 * Invocation: mmap()->smmap_common()->VOP_MAP()->sffs_map(). Once the
+	 * segment driver creates the new segment via segvn_create(), it'll
+	 * invoke down the line VOP_ADDMAP()->sffs_addmap()
+	 */
+	int error = 0;
+	sfnode_t *node = VN2SFN(dvp);
+	ASSERT(node);
+	if ((flags & MAP_SHARED) && (prot & PROT_WRITE))
+		return (ENOTSUP);
+
+	if (off < 0 || len > MAXOFFSET_T - off)
+		return (ENXIO);
+
+	if (dvp->v_type != VREG)
+		return (ENODEV);
+
+	if (dvp->v_flag & VNOMAP)
+		return (ENOSYS);
+
+	if (vn_has_mandatory_locks(dvp, node->sf_stat.sf_mode))
+		return (EAGAIN);
+
+	mutex_enter(&sffs_lock);
+	as_rangelock(asp);
+
+#if defined(VBOX_VFS_SOLARIS_10U6)
+	if ((flags & MAP_FIXED) == 0)
+	{
+        if (g_fVBoxVFS_SolOldAddrMap)
+            g_VBoxVFS_SolAddrMap.MapAddr.pfnSol_map_addr_old(addrp, len, off, 1, flags);
+        else
+            g_VBoxVFS_SolAddrMap.MapAddr.pfnSol_map_addr(addrp, len, off, flags);
+		if (*addrp == NULL)
+			error = ENOMEM;
+	}
+	else
+		as_unmap(asp, *addrp, len);	/* User specified address, remove any previous mappings */
+#else
+    if (g_fVBoxVFS_SolOldAddrMap)
+	    error = g_VBoxVFS_SolAddrMap.ChooseAddr.pfnSol_choose_addr_old(asp, addrp, len, off, 1, flags);
+    else
+	    error = g_VBoxVFS_SolAddrMap.ChooseAddr.pfnSol_choose_addr(asp, addrp, len, off, flags);
+#endif
+
+	if (error)
+	{
+		as_rangeunlock(asp);
+		mutex_exit(&sffs_lock);
+		return (error);
+	}
+
+	segvn_crargs_t vnodeargs;
+	memset(&vnodeargs, 0, sizeof(vnodeargs));
+	vnodeargs.vp = dvp;
+	vnodeargs.cred = credp;
+	vnodeargs.offset = off;
+	vnodeargs.type = flags & MAP_TYPE;
+	vnodeargs.prot = prot;
+	vnodeargs.maxprot = maxprot;
+	vnodeargs.flags = flags & ~MAP_TYPE;
+	vnodeargs.amp = NULL;		/* anon. mapping */
+	vnodeargs.szc = 0;			/* preferred page size code */
+	vnodeargs.lgrp_mem_policy_flags = 0;
+
+	error = as_map(asp, *addrp, len, segvn_create, &vnodeargs);
+
+	as_rangeunlock(asp);
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_addmap(
+	vnode_t		*dvp,
+	offset_t	off,
+	struct as	*asp,
+	caddr_t		addr,
+	size_t		len,
+	uchar_t		prot,
+	uchar_t		maxprot,
+	uint_t		flags,
+	cred_t		*credp
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	, caller_context_t *ct
+#endif
+	)
+{
+	if (dvp->v_flag & VNOMAP)
+		return (ENOSYS);
+	return (0);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_delmap(
+	vnode_t		*dvp,
+	offset_t	off,
+	struct as	*asp,
+	caddr_t		addr,
+	size_t		len,
+	uint_t		prot,
+	uint_t		maxprot,
+	uint_t		flags,
+	cred_t		*credp
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	, caller_context_t *ct
+#endif
+	)
+{
+	if (dvp->v_flag & VNOMAP)
+		return (ENOSYS);
+
+	return (0);
+}
+#endif /* VBOXVFS_WITH_MMAP */
+
+
+/*ARGSUSED*/
+static int
+sffs_readlink(
+	vnode_t		*vp,
+	uio_t		*uiop,
+	cred_t		*cred
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	,
+	caller_context_t *ct
+#endif
+	)
+{
+	sfnode_t	*node;
+	int			error = 0;
+	char		*target = NULL;
+
+	if (uiop->uio_iovcnt != 1)
+		return (EINVAL);
+
+	if (vp->v_type != VLNK)
+		return (EINVAL);
+
+	mutex_enter(&sffs_lock);
+	node = VN2SFN(vp);
+
+	target = kmem_alloc(MAXPATHLEN, KM_SLEEP);
+
+	error = sfprov_readlink(node->sf_sffs->sf_handle, node->sf_path, target,
+	    MAXPATHLEN);
+	if (error)
+		goto done;
+
+	error = uiomove(target, strlen(target), UIO_READ, uiop);
+
+done:
+	mutex_exit(&sffs_lock);
+	if (target)
+		kmem_free(target, MAXPATHLEN);
+	return (error);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_symlink(
+	vnode_t		*dvp,
+	char		*linkname,
+	vattr_t		*vap,
+	char		*target,
+	cred_t		*cred
+#if !defined(VBOX_VFS_SOLARIS_10U6)
+	,
+	caller_context_t *ct,
+	int		flags
+#endif
+	)
+{
+	sfnode_t	*dir;
+	sfnode_t	*node;
+	sffs_stat_t  stat;
+	int			 error = 0;
+	char		*fullpath;
+
+	/*
+	 * These should never happen
+	 */
+	ASSERT(linkname != NULL);
+	ASSERT(strcmp(linkname, "") != 0);
+	ASSERT(strcmp(linkname, ".") != 0);
+	ASSERT(strcmp(linkname, "..") != 0);
+
+	/*
+	 * Basic checks.
+	 */
+	if (vap->va_type != VLNK)
+		return (EINVAL);
+
+	mutex_enter(&sffs_lock);
+
+	if (sfnode_lookup(VN2SFN(dvp), linkname, VNON, 0, NULL, 0, NULL) !=
+		NULL) {
+		error = EEXIST;
+		goto done;
+	}
+
+	dir = VN2SFN(dvp);
+	error = sfnode_access(dir, VWRITE, cred);
+	if (error)
+		goto done;
+
+	/*
+	 * Create symlink. Note that we ignore vap->va_mode because generally
+	 * we can't change the attributes of the symlink itself.
+	 */
+	fullpath = sfnode_construct_path(dir, linkname);
+	error = sfprov_symlink(dir->sf_sffs->sf_handle, fullpath, target,
+	    &stat);
+	kmem_free(fullpath, strlen(fullpath) + 1);
+	if (error)
+		goto done;
+
+	node = sfnode_lookup(dir, linkname, VLNK, 0, &stat,
+		sfnode_cur_time_usec(), NULL);
+
+	sfnode_invalidate_stat_cache(dir);
+	sfnode_clear_dir_list(dir);
+
+done:
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_remove(
+	vnode_t		*dvp,
+	char		*name,
+	cred_t		*cred,
+	caller_context_t *ct,
+	int		flags)
+{
+	vnode_t		*vp;
+	sfnode_t	*node;
+	int		error;
+
+	/*
+	 * These should never happen
+	 */
+	ASSERT(name != NULL);
+	ASSERT(strcmp(name, "..") != 0);
+
+	error = sffs_lookup(dvp, name, &vp,
+	    NULL, 0, NULL, cred, ct, NULL, NULL);
+	if (error)
+		return (error);
+	node = VN2SFN(vp);
+
+	mutex_enter(&sffs_lock);
+	error = sfnode_access(VN2SFN(dvp), VEXEC | VWRITE, cred);
+	if (error)
+		goto done;
+
+	/*
+	 * If anything else is using this vnode, then fail the remove.
+	 * Why?  Windows hosts can't sfprov_remove() a file that is open,
+	 * so we have to sfprov_close() it first.
+	 * There is no errno for this - since it's not a problem on UNIX,
+	 * but ETXTBSY is the closest.
+	 */
+	if (node->sf_file != NULL) {
+		if (vp->v_count > 1) {
+			error = ETXTBSY;
+			goto done;
+		}
+		(void)sfprov_close(node->sf_file);
+		node->sf_file = NULL;
+	}
+
+	/*
+	 * Remove the file on the host and mark the node as stale.
+	 */
+	sfnode_invalidate_stat_cache(VN2SFN(dvp));
+
+	error = sfprov_remove(node->sf_sffs->sf_handle, node->sf_path,
+		node->sf_type == VLNK);
+	if (error == ENOENT || error == 0)
+		sfnode_make_stale(node);
+
+	if (node->sf_parent)
+		sfnode_clear_dir_list(node->sf_parent);
+done:
+	mutex_exit(&sffs_lock);
+	VN_RELE(vp);
+	return (error);
+}
+
+/*ARGSUSED*/
+static int
+sffs_rename(
+	vnode_t		*old_dir,
+	char		*old_nm,
+	vnode_t		*new_dir,
+	char		*new_nm,
+	cred_t		*cred,
+	caller_context_t *ct,
+	int		flags)
+{
+	char		*newpath;
+	int		error;
+	sfnode_t	*node;
+
+	if (strcmp(new_nm, "") == 0 ||
+	    strcmp(new_nm, ".") == 0 ||
+	    strcmp(new_nm, "..") == 0 ||
+	    strcmp(old_nm, "") == 0 ||
+	    strcmp(old_nm, ".") == 0 ||
+	    strcmp(old_nm, "..") == 0)
+		return (EINVAL);
+
+	/*
+	 * make sure we have permission to do the rename
+	 */
+	mutex_enter(&sffs_lock);
+	error = sfnode_access(VN2SFN(old_dir), VEXEC | VWRITE, cred);
+	if (error == 0 && new_dir != old_dir)
+		error = sfnode_access(VN2SFN(new_dir), VEXEC | VWRITE, cred);
+	if (error)
+		goto done;
+
+	node = sfnode_lookup(VN2SFN(old_dir), old_nm, VNON, 0, NULL, 0, NULL);
+	if (node == NULL) {
+		error = ENOENT;
+		goto done;
+	}
+
+	/*
+	 * Rename the file on the host and in our caches.
+	 */
+	sfnode_invalidate_stat_cache(node);
+	sfnode_invalidate_stat_cache(VN2SFN(old_dir));
+	sfnode_invalidate_stat_cache(VN2SFN(new_dir));
+
+	newpath = sfnode_construct_path(VN2SFN(new_dir), new_nm);
+	error = sfprov_rename(node->sf_sffs->sf_handle, node->sf_path, newpath,
+	    node->sf_type == VDIR);
+	if (error == 0)
+		sfnode_rename(node, VN2SFN(new_dir), newpath);
+	else {
+		kmem_free(newpath, strlen(newpath) + 1);
+		if (error == ENOENT)
+			sfnode_make_stale(node);
+	}
+done:
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+
+/*ARGSUSED*/
+static int
+sffs_fsync(vnode_t *vp, int flag, cred_t *cr, caller_context_t *ct)
+{
+	sfnode_t *node;
+	int		error;
+
+	/*
+	 * Ask the host to sync any data it may have cached for open files.
+	 */
+	mutex_enter(&sffs_lock);
+	node = VN2SFN(vp);
+	if (node->sf_file == NULL)
+		error = EBADF;
+	else if (node->sf_sffs->sf_fsync)
+		error = sfprov_fsync(node->sf_file);
+	else
+		error = 0;
+	mutex_exit(&sffs_lock);
+	return (error);
+}
+
+/*
+ * This may be the last reference, possibly time to close the file and
+ * destroy the vnode. If the sfnode is stale, we'll destroy that too.
+ */
+/*ARGSUSED*/
+static void
+#if defined(VBOX_VFS_SOLARIS_10U6)
+sffs_inactive(vnode_t *vp, cred_t *cr)
+#else
+sffs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
+#endif
+{
+	sfnode_t *node;
+
+	/*
+	 * nothing to do if this isn't the last use
+	 */
+	mutex_enter(&sffs_lock);
+	node = VN2SFN(vp);
+	mutex_enter(&vp->v_lock);
+	if (vp->v_count > 1) {
+		--vp->v_count;
+		mutex_exit(&vp->v_lock);
+		mutex_exit(&sffs_lock);
+		return;
+	}
+
+	if (vn_has_cached_data(vp)) {
+#ifdef VBOXVFS_WITH_MMAP
+		/* We're fine with releasing the vnode lock here as we should be covered by the sffs_lock */
+		mutex_exit(&vp->v_lock);
+		/* We won't have any dirty pages, this will just invalidate (destroy) the pages and move it to the cachelist. */
+		pvn_vplist_dirty(vp, 0 /* offset */, sffs_discardpage, B_INVAL, cr);
+		mutex_enter(&vp->v_lock);
+#else
+		panic("sffs_inactive() found cached data");
+#endif
+	}
+
+	/*
+	 * destroy the vnode
+	 */
+	node->sf_vnode = NULL;
+	mutex_exit(&vp->v_lock);
+	vn_invalid(vp);
+	vn_free(vp);
+	LogFlowFunc(("  %s vnode cleared\n", node->sf_path));
+
+	/*
+	 * Close the sf_file for the node.
+	 */
+	if (node->sf_file != NULL) {
+		(void)sfprov_close(node->sf_file);
+		node->sf_file = NULL;
+	}
+
+	/*
+	 * Free the directory entries for the node. This should normally
+	 * have been taken care of in sffs_close(), but better safe than
+	 * sorry.
+	 */
+	sfnode_clear_dir_list(node);
+
+	/*
+	 * If the node is stale, we can also destroy it.
+	 */
+	if (node->sf_is_stale && node->sf_children == 0)
+		sfnode_destroy(node);
+
+	mutex_exit(&sffs_lock);
+	return;
+}
+
+/*
+ * All the work for this is really done in sffs_lookup().
+ */
+/*ARGSUSED*/
+static int
+sffs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
+{
+	sfnode_t *node;
+	int	error = 0;
+
+	mutex_enter(&sffs_lock);
+
+	node = VN2SFN(*vpp);
+	sfnode_open(node, flag);
+	if (node->sf_file == NULL)
+		error = EINVAL;
+	mutex_exit(&sffs_lock);
+
+	return (error);
+}
+
+/*
+ * All the work for this is really done in inactive.
+ */
+/*ARGSUSED*/
+static int
+sffs_close(
+	vnode_t *vp,
+	int flag,
+	int count,
+	offset_t offset,
+	cred_t *cr,
+	caller_context_t *ct)
+{
+	sfnode_t *node;
+
+	mutex_enter(&sffs_lock);
+	node = VN2SFN(vp);
+
+	/*
+	 * Free the directory entries for the node. We do this on this call
+	 * here because the directory node may not become inactive for a long
+	 * time after the readdir is over. Case in point, if somebody cd's into
+	 * the directory then it won't become inactive until they cd away again.
+	 * In such a case we would end up with the directory listing not getting
+	 * updated (i.e. the result of 'ls' always being the same) until they
+	 * change the working directory.
+	 */
+	sfnode_clear_dir_list(node);
+
+	sfnode_invalidate_stat_cache(node);
+
+	if (node->sf_file != NULL && vp->v_count <= 1)
+	{
+		(void)sfprov_close(node->sf_file);
+		node->sf_file = NULL;
+	}
+
+	mutex_exit(&sffs_lock);
+	return (0);
+}
+
+/* ARGSUSED */
+static int
+sffs_seek(vnode_t *v, offset_t o, offset_t *no, caller_context_t *ct)
+{
+	if (*no < 0 || *no > MAXOFFSET_T)
+		return (EINVAL);
+
+	if (v->v_type == VDIR)
+	{
+		sffs_dirents_t *cur_buf = VN2SFN(v)->sf_dir_list;
+		off_t offset = 0;
+
+		if (cur_buf == NULL)
+			return (0);
+
+		while (cur_buf != NULL) {
+			if (*no >= offset && *no <= offset + cur_buf->sf_len)
+				return (0);
+			offset += cur_buf->sf_len;
+			cur_buf = cur_buf->sf_next;
+		}
+		return (EINVAL);
+	}
+	return (0);
+}
+
+
+
+/*
+ * By returning an error for this, we prevent anything in sffs from
+ * being re-exported by NFS
+ */
+/* ARGSUSED */
+static int
+sffs_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
+{
+	return (ENOTSUP);
+}
+
+/*
+ * vnode operations for regular files
+ */
+const fs_operation_def_t sffs_ops_template[] = {
+#if defined(VBOX_VFS_SOLARIS_10U6)
+	VOPNAME_ACCESS,		sffs_access,
+	VOPNAME_CLOSE,		sffs_close,
+	VOPNAME_CREATE,		sffs_create,
+	VOPNAME_FID,		sffs_fid,
+	VOPNAME_FSYNC,		sffs_fsync,
+	VOPNAME_GETATTR,	sffs_getattr,
+	VOPNAME_INACTIVE,	sffs_inactive,
+	VOPNAME_LOOKUP,		sffs_lookup,
+	VOPNAME_MKDIR,		sffs_mkdir,
+	VOPNAME_OPEN,		sffs_open,
+	VOPNAME_PATHCONF,	sffs_pathconf,
+	VOPNAME_READ,		sffs_read,
+	VOPNAME_READDIR,	sffs_readdir,
+	VOPNAME_READLINK,	sffs_readlink,
+	VOPNAME_REMOVE,		sffs_remove,
+	VOPNAME_RENAME,		sffs_rename,
+	VOPNAME_RMDIR,		sffs_rmdir,
+	VOPNAME_SEEK,		sffs_seek,
+	VOPNAME_SETATTR,	sffs_setattr,
+	VOPNAME_SPACE,		sffs_space,
+	VOPNAME_SYMLINK,	sffs_symlink,
+	VOPNAME_WRITE,		sffs_write,
+
+# ifdef VBOXVFS_WITH_MMAP
+	VOPNAME_MAP,		sffs_map,
+	VOPNAME_ADDMAP,		sffs_addmap,
+	VOPNAME_DELMAP,		sffs_delmap,
+	VOPNAME_GETPAGE,	sffs_getpage,
+	VOPNAME_PUTPAGE,	sffs_putpage,
+# endif
+
+	NULL,			NULL
+#else
+	VOPNAME_ACCESS,		{ .vop_access = sffs_access },
+	VOPNAME_CLOSE,		{ .vop_close = sffs_close },
+	VOPNAME_CREATE,		{ .vop_create = sffs_create },
+	VOPNAME_FID,		{ .vop_fid = sffs_fid },
+	VOPNAME_FSYNC,		{ .vop_fsync = sffs_fsync },
+	VOPNAME_GETATTR,	{ .vop_getattr = sffs_getattr },
+	VOPNAME_INACTIVE,	{ .vop_inactive = sffs_inactive },
+	VOPNAME_LOOKUP,		{ .vop_lookup = sffs_lookup },
+	VOPNAME_MKDIR,		{ .vop_mkdir = sffs_mkdir },
+	VOPNAME_OPEN,		{ .vop_open = sffs_open },
+	VOPNAME_PATHCONF,	{ .vop_pathconf = sffs_pathconf },
+	VOPNAME_READ,		{ .vop_read = sffs_read },
+	VOPNAME_READDIR,	{ .vop_readdir = sffs_readdir },
+	VOPNAME_READLINK,	{ .vop_readlink = sffs_readlink },
+	VOPNAME_REMOVE,		{ .vop_remove = sffs_remove },
+	VOPNAME_RENAME,		{ .vop_rename = sffs_rename },
+	VOPNAME_RMDIR,		{ .vop_rmdir = sffs_rmdir },
+	VOPNAME_SEEK,		{ .vop_seek = sffs_seek },
+	VOPNAME_SETATTR,	{ .vop_setattr = sffs_setattr },
+	VOPNAME_SPACE,		{ .vop_space = sffs_space },
+	VOPNAME_SYMLINK,	{ .vop_symlink = sffs_symlink },
+	VOPNAME_WRITE,		{ .vop_write = sffs_write },
+
+# ifdef VBOXVFS_WITH_MMAP
+	VOPNAME_MAP,		{ .vop_map = sffs_map },
+	VOPNAME_ADDMAP,		{ .vop_addmap = sffs_addmap },
+	VOPNAME_DELMAP,		{ .vop_delmap = sffs_delmap },
+	VOPNAME_GETPAGE,	{ .vop_getpage = sffs_getpage },
+	VOPNAME_PUTPAGE,	{ .vop_putpage = sffs_putpage },
+# endif
+
+	NULL,			NULL
+#endif
+};
+
+/*
+ * Also, init and fini functions...
+ */
+int
+sffs_vnode_init(void)
+{
+	int err;
+
+	err = vn_make_ops("sffs", sffs_ops_template, &sffs_ops);
+	if (err)
+		return (err);
+
+	avl_create(&sfnodes, sfnode_compare, sizeof (sfnode_t),
+	    offsetof(sfnode_t, sf_linkage));
+	avl_create(&stale_sfnodes, sfnode_compare, sizeof (sfnode_t),
+	    offsetof(sfnode_t, sf_linkage));
+
+	sffs_buffer = kmem_alloc(PAGESIZE, KM_SLEEP);
+
+	return (0);
+}
+
+void
+sffs_vnode_fini(void)
+{
+	if (sffs_ops)
+		vn_freevnodeops(sffs_ops);
+	ASSERT(avl_first(&sfnodes) == NULL);
+	avl_destroy(&sfnodes);
+	if (sffs_buffer != NULL) {
+		kmem_free(sffs_buffer, PAGESIZE);
+		sffs_buffer = NULL;
+	}
+}
+
+/*
+ * Utility at unmount to get all nodes in that mounted filesystem removed.
+ */
+int
+sffs_purge(struct sffs_data *sffs)
+{
+	sfnode_t *node;
+	sfnode_t *prev;
+
+	/*
+	 * Check that no vnodes are active.
+	 */
+	if (sffs->sf_rootnode->v_count > 1)
+		return (-1);
+	for (node = avl_first(&sfnodes); node;
+	    node = AVL_NEXT(&sfnodes, node)) {
+		if (node->sf_sffs == sffs && node->sf_vnode &&
+		    node->sf_vnode != sffs->sf_rootnode)
+			return (-1);
+	}
+	for (node = avl_first(&stale_sfnodes); node;
+	    node = AVL_NEXT(&stale_sfnodes, node)) {
+		if (node->sf_sffs == sffs && node->sf_vnode &&
+		    node->sf_vnode != sffs->sf_rootnode)
+			return (-1);
+	}
+
+	/*
+	 * All clear to destroy all node information. Since there are no
+	 * vnodes, the make stale will cause deletion.
+	 */
+	VN_RELE(sffs->sf_rootnode);
+	mutex_enter(&sffs_lock);
+	for (prev = NULL;;) {
+		if (prev == NULL)
+			node = avl_first(&sfnodes);
+		else
+			node = AVL_NEXT(&sfnodes, prev);
+
+		if (node == NULL)
+			break;
+
+		if (node->sf_sffs == sffs) {
+			if (node->sf_vnode != NULL)
+				panic("vboxfs: purge hit active vnode");
+			sfnode_make_stale(node);
+		} else {
+			prev = node;
+		}
+	}
+	mutex_exit(&sffs_lock);
+	return (0);
+}
+
+#if 0
+/* Debug helper functions */
+static void
+sfnode_print(sfnode_t *node)
+{
+	Log(("0x%p", node));
+	Log((" type=%s (%d)",
+		node->sf_type == VDIR ? "VDIR" :
+		node->sf_type == VNON ? "VNON" :
+		node->sf_type == VLNK ? "VLNK" :
+		node->sf_type == VREG ? "VREG" : "other", node->sf_type));
+	Log((" ino=%d", (uint_t)node->sf_ino));
+	Log((" path=%s", node->sf_path));
+	Log((" parent=0x%p", node->sf_parent));
+	if (node->sf_children)
+		Log((" children=%d", node->sf_children));
+	if (node->sf_vnode)
+		Log((" vnode=0x%p", node->sf_vnode));
+	Log(("%s\n", node->sf_is_stale ? " STALE" : ""));
+}
+
+static void
+sfnode_list(void)
+{
+	sfnode_t *n;
+	for (n = avl_first(&sfnodes); n != NULL; n = AVL_NEXT(&sfnodes, n))
+		sfnode_print(n);
+	for (n = avl_first(&stale_sfnodes); n != NULL;
+	    n = AVL_NEXT(&stale_sfnodes, n))
+		sfnode_print(n);
+}
+#endif
+
diff --git a/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.h b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.h
new file mode 100644
index 00000000..5cacd523
--- /dev/null
+++ b/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.h
@@ -0,0 +1,89 @@
+/* $Id: vboxfs_vnode.h $ */
+/** @file
+ * VirtualBox File System for Solaris Guests, VNode header.
+ */
+
+/*
+ * Copyright (C) 2009-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_vnode_h
+#define GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_vnode_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <sys/t_lock.h>
+#include <sys/avl.h>
+#include <vm/seg.h>
+#include <vm/seg_vn.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * sfnode is the file system dependent vnode data for vboxsf.
+ * sfnode's also track all files ever accessed, both open and closed.
+ * It duplicates some of the information in vnode, since it holds
+ * information for files that may have been completely closed.
+ *
+ * The sfnode_t's are stored in an AVL tree sorted by:
+ *	sf_sffs, sf_path
+ */
+typedef struct sfnode {
+	avl_node_t	sf_linkage;	/* AVL tree linkage */
+	struct sffs_data *sf_sffs;	/* containing mounted file system */
+	char		*sf_path;	/* full pathname to file or dir */
+	uint64_t	sf_ino;		/* assigned unique ID number */
+	vnode_t		*sf_vnode;	/* vnode if active */
+	sfp_file_t	*sf_file;	/* non NULL if open */
+	int			sf_flag;    /* last opened file-mode. */
+	struct sfnode	*sf_parent;	/* parent sfnode of this one */
+	uint16_t	sf_children;	/* number of children sfnodes */
+	uint8_t		sf_type;	/* VDIR or VREG */
+	uint8_t		sf_is_stale;	/* this is stale and should be purged */
+	sffs_stat_t	sf_stat;	/* cached file attrs for this node */
+	uint64_t	sf_stat_time;	/* last-modified time of sf_stat */
+	sffs_dirents_t	*sf_dir_list;	/* list of entries for this directory */
+} sfnode_t;
+
+#define VN2SFN(vp) ((sfnode_t *)(vp)->v_data)
+
+#ifdef _KERNEL
+extern int sffs_vnode_init(void);
+extern void sffs_vnode_fini(void);
+extern sfnode_t *sfnode_make(struct sffs_data *, char *, vtype_t, sfp_file_t *,
+    sfnode_t *parent, sffs_stat_t *, uint64_t stat_time);
+extern vnode_t *sfnode_get_vnode(sfnode_t *);
+
+/*
+ * Purge all cached information about a shared file system at unmount
+ */
+extern int sffs_purge(struct sffs_data *);
+
+extern kmutex_t sffs_lock;
+#endif /* _KERNEL */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* !GA_INCLUDED_SRC_solaris_SharedFolders_vboxfs_vnode_h */
diff --git a/src/VBox/Additions/solaris/Virtio/Makefile.kmk b/src/VBox/Additions/solaris/Virtio/Makefile.kmk
new file mode 100644
index 00000000..2619a7ea
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/Makefile.kmk
@@ -0,0 +1,54 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for Solaris Virtio drivers.
+#
+
+#
+# Copyright (C) 2010-2020 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+SUB_DEPTH = ../../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#ifneq ($(KBUILD_HOST),solaris)
+#$(error "The Solaris guest additions can only be built on Solaris!")
+#endif
+
+#
+# virtionet ("virtnet" on Solaris) - The Virtio Network Drivers
+#
+SYSMODS.solaris        += virtionet
+virtionet_NAME.solaris  = virtnet
+virtionet_TEMPLATE      = VBOXGUESTR0
+virtionet_DEFS          = VBOX_WITH_HGCM VBOX_SVN_REV=$(VBOX_SVN_REV) VBOX_VERSION_STRING=\"$(VBOX_VERSION_STRING)\"
+virtionet_DEPS         += $(VBOX_SVN_REV_KMK)
+virtionet_INCS         := .
+virtionet_SOURCES       = \
+	Virtio-solaris.c \
+	VirtioPci-solaris.c \
+	VirtioRing-solaris.c \
+	VirtioNet-solaris.c
+# virtionet should resolve all IPRT bits from vboxguest.
+#virtionet_LIBS          = \
+#	$(VBOX_LIB_IPRT_GUEST_R0)
+virtionet_LDFLAGS      += -N drv/vboxguest -N misc/mac
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/Additions/solaris/Virtio/Virtio-solaris.c b/src/VBox/Additions/solaris/Virtio/Virtio-solaris.c
new file mode 100644
index 00000000..07b0c3e8
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/Virtio-solaris.c
@@ -0,0 +1,214 @@
+/* $Id: Virtio-solaris.c $ */
+/** @file
+ * VirtualBox Guest Additions - Virtio Driver for Solaris.
+ */
+
+/*
+ * Copyright (C) 2010-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "Virtio-solaris.h"
+
+#include <iprt/assert.h>
+#include <iprt/mem.h>
+#include <VBox/log.h>
+
+
+/**
+ * Virtio Attach routine that should be called from all Virtio drivers' attach
+ * routines.
+ *
+ * @param pDip              The module structure instance.
+ * @param enmCmd            Operation type (attach/resume).
+ * @param pDeviceOps        Pointer to device ops structure.
+ * @param pHyperOps         Pointer to hypervisor ops structure.
+ *
+ * @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
+ */
+int VirtioAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd, PVIRTIODEVICEOPS pDeviceOps, PVIRTIOHYPEROPS pHyperOps)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioAttach: pDip=%p enmCmd=%d pDeviceOps=%p pHyperOps=%p\n", pDip, enmCmd, pDeviceOps, pHyperOps));
+
+    AssertReturn(pDip, DDI_EINVAL);
+    AssertReturn(pDeviceOps, DDI_EINVAL);
+    AssertReturn(pHyperOps, DDI_EINVAL);
+
+    if (enmCmd != DDI_ATTACH)
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioAttach: Invalid enmCmd=%#x expected DDI_ATTACH\n", enmCmd));
+        return DDI_FAILURE;
+    }
+
+    int rc = DDI_FAILURE;
+    PVIRTIODEVICE pDevice = RTMemAllocZ(sizeof(VIRTIODEVICE));
+    if (RT_LIKELY(pDevice))
+    {
+        pDevice->pDip = pDip;
+        pDevice->pDeviceOps = pDeviceOps;
+        pDevice->pHyperOps = pHyperOps;
+
+        pDevice->pvDevice = pDevice->pDeviceOps->pfnAlloc(pDevice);
+        if (RT_LIKELY(pDevice->pvDevice))
+        {
+            pDevice->pvHyper = pDevice->pHyperOps->pfnAlloc(pDevice);
+            if (RT_LIKELY(pDevice->pvHyper))
+            {
+                /*
+                 * Attach hypervisor interface and obtain features supported by host.
+                 */
+                rc = pDevice->pHyperOps->pfnAttach(pDevice);
+                if (rc == DDI_SUCCESS)
+                {
+                    pDevice->fHostFeatures = pDevice->pHyperOps->pfnGetFeatures(pDevice);
+                    LogFlow((VIRTIOLOGNAME ":VirtioAttach: Host features=%#x\n", pDevice->fHostFeatures));
+
+                    /*
+                     * Attach the device type interface.
+                     */
+                    rc = pDevice->pDeviceOps->pfnAttach(pDevice);
+                    if (rc == DDI_SUCCESS)
+                    {
+                        ddi_set_driver_private(pDip, pDevice);
+                        return DDI_SUCCESS;
+                    }
+                    else
+                        LogRel((VIRTIOLOGNAME ":VirtioAttach: DeviceOps pfnAttach failed. rc=%d\n", rc));
+
+                    pDevice->pHyperOps->pfnDetach(pDevice);
+                }
+                else
+                    LogRel((VIRTIOLOGNAME ":VirtioAttach: HyperOps pfnAttach failed. rc=%d\n", rc));
+
+                pDevice->pHyperOps->pfnFree(pDevice);
+            }
+            else
+                LogRel((VIRTIOLOGNAME ":VirtioAttach: HyperOps->pfnAlloc failed!\n"));
+
+            pDevice->pDeviceOps->pfnFree(pDevice);
+        }
+        else
+            LogRel((VIRTIOLOGNAME ":VirtioAttach: DeviceOps->pfnAlloc failed!\n"));
+
+        RTMemFree(pDevice);
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioAttach: failed to alloc %u bytes for device structure.\n", sizeof(VIRTIODEVICE)));
+
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Virtio Detach routine that should be called from all Virtio drivers' detach
+ * routines.
+ *
+ * @param pDip              The module structure instance.
+ * @param enmCmd            Operation type (detach/suspend).
+ *
+ * @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
+ */
+int VirtioDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioDetach pDip=%p enmCmd=%d\n", pDip, enmCmd));
+
+    PVIRTIODEVICE pDevice = ddi_get_driver_private(pDip);
+    if (RT_UNLIKELY(!pDevice))
+        return DDI_FAILURE;
+
+    if (enmCmd != DDI_DETACH)
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioDetach: Invalid enmCmd=%#x expected DDI_DETACH.\n", enmCmd));
+        return DDI_FAILURE;
+    }
+
+    int rc = pDevice->pDeviceOps->pfnDetach(pDevice);
+    if (rc == DDI_SUCCESS)
+    {
+        pDevice->pHyperOps->pfnDetach(pDevice);
+        pDevice->pDeviceOps->pfnFree(pDevice);
+        pDevice->pvDevice = NULL;
+        pDevice->pHyperOps->pfnFree(pDevice);
+        pDevice->pvHyper = NULL;
+
+        ddi_set_driver_private(pDevice->pDip, NULL);
+        RTMemFree(pDevice);
+        return DDI_SUCCESS;
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioDetach: DeviceOps pfnDetach failed. rc=%d\n", rc));
+
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Allocates a Virtio Queue object and assigns it an index.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param Index             Queue index.
+ *
+ * @return A pointer to a Virtio Queue instance.
+ */
+PVIRTIOQUEUE VirtioGetQueue(PVIRTIODEVICE pDevice, uint16_t Index)
+{
+    PVIRTIOQUEUE pQueue = RTMemAllocZ(sizeof(VIRTIOQUEUE));
+    if (RT_UNLIKELY(!pQueue))
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioGetQueue: failed to alloc memory for %u bytes.\n", sizeof(VIRTIOQUEUE)));
+        return NULL;
+    }
+
+    pQueue->QueueIndex = Index;
+    pQueue->pvData     = pDevice->pHyperOps->pfnGetQueue(pDevice, pQueue);
+    if (RT_UNLIKELY(!pQueue->pvData))
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioGetQueue: HyperOps GetQueue failed!\n"));
+        RTMemFree(pQueue);
+        return NULL;
+    }
+
+    AssertReturn(pQueue->pQueue, NULL);
+    AssertReturn(pQueue->Ring.cDesc > 0, NULL);
+
+    /** @todo enable interrupt. */
+
+    return pQueue;
+}
+
+
+/**
+ * Puts a queue and destroys the instance.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param pQueue            Pointer to the Virtio queue.
+ */
+void VirtioPutQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
+{
+    AssertReturnVoid(pDevice);
+    AssertReturnVoid(pQueue);
+
+    pDevice->pHyperOps->pfnPutQueue(pDevice, pQueue);
+    RTMemFree(pQueue);
+}
+
diff --git a/src/VBox/Additions/solaris/Virtio/Virtio-solaris.h b/src/VBox/Additions/solaris/Virtio/Virtio-solaris.h
new file mode 100644
index 00000000..6146cd70
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/Virtio-solaris.h
@@ -0,0 +1,195 @@
+/* $Id: Virtio-solaris.h $ */
+/** @file
+ * VirtualBox Guest Additions: Virtio Driver for Solaris, header.
+ */
+
+/*
+ * Copyright (C) 2010-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_Virtio_Virtio_solaris_h
+#define GA_INCLUDED_SRC_solaris_Virtio_Virtio_solaris_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <sys/sunddi.h>
+
+/** Release log descriptive prefix. */
+#define VIRTIOLOGNAME           "Virtio"
+/** Buffer continues via the Next field */
+#define VIRTIO_FLAGS_RING_DESC_NEXT       RT_BIT(0)
+/** Buffer is write-only, else is read-only.  */
+#define VIRTIO_FLAGS_RING_DESC_WRITE      RT_BIT(1)
+/** Indirect buffer (buffer contains list of buffer descriptors) */
+#define VIRTIO_FLAGS_RING_DESC_INDIRECT   RT_BIT(2)
+
+/* Values from our Virtio.h */
+#define VIRTIO_PCI_STATUS_ACK             0x01
+#define VIRTIO_PCI_STATUS_DRV             0x02
+#define VIRTIO_PCI_STATUS_DRV_OK          0x04
+#define VIRTIO_PCI_STATUS_FAILED          0x80
+
+/**
+ * The ring descriptor table refers to the buffers the guest is using for the
+ * device.
+ */
+struct VirtioRingDesc
+{
+    uint64_t                AddrBuf;            /* Physical address of buffer. */
+    uint32_t                cbBuf;              /* Length of the buffer in bytes. */
+    uint16_t                fFlags;             /* Flags of the next buffer. */
+    uint16_t                Next;               /* Index of the next buffer. */
+};
+typedef struct VirtioRingDesc VIRTIORINGDESC;
+typedef VIRTIORINGDESC *PVIRTIORINGDESC;
+
+/**
+ * The available ring refers to what descriptors are being offered to the
+ * device.
+ */
+struct VirtioRingAvail
+{
+    uint16_t                fFlags;             /* Interrupt supression flag. */
+    uint16_t                Index;              /* Index of available ring. */
+    uint16_t                aRings[1];          /* Array of indices into descriptor table. */
+};
+typedef struct VirtioRingAvail VIRTIORINGAVAIL;
+typedef VIRTIORINGAVAIL *PVIRTIORINGAVAIL;
+
+/**
+ * The used ring refers to the buffers the device is done using them. The
+ * element is a pair-descriptor refers to the buffer once the device is done
+ * with the buffer.
+ */
+struct VirtioRingUsedElem
+{
+    uint32_t                Index;              /* Index of start of used descriptor chain. */
+    uint32_t                cbElem;             /* Number of bytes written into the buffer. */
+};
+typedef struct VirtioRingUsedElem VIRTIORINGUSEDELEM;
+typedef VIRTIORINGUSEDELEM *PVIRTIORINGUSEDELEM;
+
+/**
+ * The Virtio Ring which contains the descriptors.
+ */
+struct VirtioRing
+{
+    uint_t                  cDesc;              /* Number of descriptors. */
+    PVIRTIORINGDESC         pRingDesc;          /* Pointer to ring descriptor. */
+    PVIRTIORINGAVAIL        pRingAvail;         /* Pointer to available ring. */
+    PVIRTIORINGUSEDELEM     pRingUsedElem;      /* Pointer to used ring element. */
+};
+typedef struct VirtioRing VIRTIORING;
+typedef VIRTIORING *PVIRTIORING;
+
+struct VirtioDevice;
+struct VirtioQueue;
+
+typedef void     *(*PFNVIRTIOALLOC)(struct VirtioDevice *pDevice);
+typedef void      (*PFNVIRTIOFREE)(struct VirtioDevice *pDevice);
+typedef int       (*PFNVIRTIOATTACH)(struct VirtioDevice *pDevice);
+typedef int       (*PFNVIRTIODETACH)(struct VirtioDevice *pDevice);
+typedef uint32_t  (*PFNVIRTIOGETFEATURES)(struct VirtioDevice *pDevice);
+typedef void      (*PFNVIRTIOSETFEATURES)(struct VirtioDevice *pDevice, uint32_t fFeatures);
+typedef void      (*PFNVIRTIOGET)(struct VirtioDevice *pDevice, off_t off, void *pv, size_t cb);
+typedef void      (*PFNVIRTIOSET)(struct VirtioDevice *pDevice, off_t off, void *pv, size_t cb);
+typedef void     *(*PFNVIRTIOGETQUEUE)(struct VirtioDevice *pDevice, struct VirtioQueue *pQueue);
+typedef void      (*PFNVIRTIOPUTQUEUE)(struct VirtioDevice *pDevice, struct VirtioQueue *pQueue);
+typedef int       (*PFNVIRTIONOTIFYQUEUE)(struct VirtioDevice *pDevice, struct VirtioQueue *pQueue);
+typedef void      (*PFNVIRTIOSETSTATUS)(struct VirtioDevice *pDevice, uint8_t Status);
+
+/**
+ * Virtio device operations.
+ */
+struct VirtioDeviceOps
+{
+    PFNVIRTIOALLOC          pfnAlloc;           /* Device alloc. */
+    PFNVIRTIOFREE           pfnFree;            /* Device free. */
+    PFNVIRTIOATTACH         pfnAttach;          /* Device attach. */
+    PFNVIRTIODETACH         pfnDetach;          /* Device detach. */
+};
+typedef struct VirtioDeviceOps VIRTIODEVICEOPS;
+typedef VIRTIODEVICEOPS *PVIRTIODEVICEOPS;
+
+/**
+ * Hypervisor access operations.
+ */
+struct VirtioHyperOps
+{
+    PFNVIRTIOALLOC          pfnAlloc;           /* Hypervisor alloc. */
+    PFNVIRTIOFREE           pfnFree;            /* Hypervisor free */
+    PFNVIRTIOATTACH         pfnAttach;          /* Hypervisor attach. */
+    PFNVIRTIODETACH         pfnDetach;          /* Hypervisor detach. */
+    PFNVIRTIOGETFEATURES    pfnGetFeatures;     /* Hypervisor get features. */
+    PFNVIRTIOSETFEATURES    pfnSetFeatures;     /* Hypervisor set features. */
+    PFNVIRTIONOTIFYQUEUE    pfnNotifyQueue;     /* Hypervisor notify queue. */
+    PFNVIRTIOGET            pfnGet;             /* Hypervisor get. */
+    PFNVIRTIOSET            pfnSet;             /* Hypervisor set. */
+    PFNVIRTIOGETQUEUE       pfnGetQueue;        /* Hypervisor get queue. */
+    PFNVIRTIOPUTQUEUE       pfnPutQueue;        /* Hypervisor put queue. */
+    PFNVIRTIOSETSTATUS      pfnSetStatus;       /* Hypervisor set status. */
+};
+typedef struct VirtioHyperOps VIRTIOHYPEROPS;
+typedef VIRTIOHYPEROPS *PVIRTIOHYPEROPS;
+
+/**
+ * Virtio Queue into which buffers are posted.
+ */
+struct VirtioQueue
+{
+    VIRTIORING              Ring;               /* Ring buffer of this queue. */
+    uint16_t                cBufs;              /* Number of pushed, unnotified buffers. */
+    uint16_t                FreeHeadIndex;      /* Index of head of free list. */
+    uint16_t                QueueIndex;         /* Index of this queue. */
+    caddr_t                 pQueue;             /* Allocated DMA region for queue. */
+    void                   *pvData;             /* Queue private data. */
+};
+typedef struct VirtioQueue VIRTIOQUEUE;
+typedef VIRTIOQUEUE *PVIRTIOQUEUE;
+
+/**
+ * Virtio device descriptor, common to all Virtio devices.
+ */
+struct VirtioDevice
+{
+    dev_info_t             *pDip;               /* OS device info. */
+    PVIRTIODEVICEOPS        pDeviceOps;         /* Device hooks. */
+    void                   *pvDevice;           /* Device opaque data. */
+    PVIRTIOHYPEROPS         pHyperOps;          /* Hypervisor hooks. */
+    void                   *pvHyper;            /* Hypervisor opaque data. */
+    uint32_t                fHostFeatures;      /* Features provided by the host. */
+};
+typedef struct VirtioDevice VIRTIODEVICE;
+typedef VIRTIODEVICE *PVIRTIODEVICE;
+
+
+int VirtioAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd, PVIRTIODEVICEOPS pDeviceOps, PVIRTIOHYPEROPS pHyperOps);
+int VirtioDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd);
+
+PVIRTIOQUEUE VirtioGetQueue(PVIRTIODEVICE pDevice, uint16_t Index);
+void VirtioPutQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
+
+void VirtioRingInit(PVIRTIOQUEUE pQueue, uint_t cDescs, caddr_t virtBuf, ulong_t Align);
+int  VirtioRingPush(PVIRTIOQUEUE pQueue, paddr_t physBuf, uint32_t cbBuf, uint16_t fFlags);
+size_t VirtioRingSize(uint64_t cElements, ulong_t Align);
+
+#endif /* !GA_INCLUDED_SRC_solaris_Virtio_Virtio_solaris_h */
+
diff --git a/src/VBox/Additions/solaris/Virtio/VirtioNet-solaris.c b/src/VBox/Additions/solaris/Virtio/VirtioNet-solaris.c
new file mode 100644
index 00000000..39144b21
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/VirtioNet-solaris.c
@@ -0,0 +1,842 @@
+/* $Id: VirtioNet-solaris.c $ */
+/** @file
+ * VirtualBox Guest Additions - Virtio Network Driver for Solaris.
+ */
+
+/*
+ * Copyright (C) 2010-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "Virtio-solaris.h"
+#include "VirtioPci-solaris.h"
+
+#include <sys/conf.h>
+#include <sys/sunddi.h>
+#include <sys/mac_provider.h>
+#include <sys/strsun.h>
+#include <sys/cmn_err.h>
+
+#include <iprt/assert.h>
+#include <iprt/initterm.h>
+#include <iprt/errcore.h>
+#include <VBox/log.h>
+#include <iprt/mem.h>
+#include <iprt/rand.h>
+#include <iprt/string.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#define DEVICE_NAME               "virtnet"
+/** The module descriptions as seen in 'modinfo'. */
+#define DEVICE_DESC_DRV           "VirtualBox VirtioNet"
+
+/** Copied from "mac_ether.h" - why the heck is this not public?? All Solaris
+ *  mac clients use it... */
+#define MAC_PLUGIN_IDENT_ETHER    "mac_ether"
+
+/* Copied from our Virtio Device emulation. */
+#define VIRTIO_NET_CSUM           0x00000001      /* Host handles pkts w/ partial csum */
+#define VIRTIO_NET_GUEST_CSUM     0x00000002      /* Guest handles pkts w/ partial csum */
+#define VIRTIO_NET_MAC            0x00000020      /* Host has given MAC address. */
+#define VIRTIO_NET_GSO            0x00000040      /* Host handles pkts w/ any GSO type */
+#define VIRTIO_NET_GUEST_TSO4     0x00000080      /* Guest can handle TSOv4 in. */
+#define VIRTIO_NET_GUEST_TSO6     0x00000100      /* Guest can handle TSOv6 in. */
+#define VIRTIO_NET_GUEST_ECN      0x00000200      /* Guest can handle TSO[6] w/ ECN in. */
+#define VIRTIO_NET_GUEST_UFO      0x00000400      /* Guest can handle UFO in. */
+#define VIRTIO_NET_HOST_TSO4      0x00000800      /* Host can handle TSOv4 in. */
+#define VIRTIO_NET_HOST_TSO6      0x00001000      /* Host can handle TSOv6 in. */
+#define VIRTIO_NET_HOST_ECN       0x00002000      /* Host can handle TSO[6] w/ ECN in. */
+#define VIRTIO_NET_HOST_UFO       0x00004000      /* Host can handle UFO in. */
+#define VIRTIO_NET_MRG_RXBUF      0x00008000      /* Host can merge receive buffers. */
+#define VIRTIO_NET_STATUS         0x00010000      /* virtio_net_config.status available */
+#define VIRTIO_NET_CTRL_VQ        0x00020000      /* Control channel available */
+#define VIRTIO_NET_CTRL_RX        0x00040000      /* Control channel RX mode support */
+#define VIRTIO_NET_CTRL_VLAN      0x00080000      /* Control channel VLAN filtering */
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static void      *VirtioNetDevAlloc(PVIRTIODEVICE pDevice);
+static void       VirtioNetDevFree(PVIRTIODEVICE pDevice);
+static int        VirtioNetDevAttach(PVIRTIODEVICE pDevice);
+static int        VirtioNetDevDetach(PVIRTIODEVICE pDevice);
+
+static int        VirtioNetAttach(dev_info_t *pDip, ddi_attach_cmd_t Cmd);
+static int        VirtioNetDetach(dev_info_t *pDip, ddi_detach_cmd_t Cmd);
+
+static int        VirtioNetStat(void *pvArg, uint_t cmdStat, uint64_t *pu64Val);
+static int        VirtioNetStart(void *pvArg);
+static void       VirtioNetStop(void *pvArg);
+static int        VirtioNetSetPromisc(void *pvArg, boolean_t fPromiscOn);
+static int        VirtioNetSetMulticast(void *pvArg, boolean_t fAdd, const uint8_t *pbMac);
+static int        VirtioNetSetUnicast(void *pvArg, const uint8_t *pbMac);
+static boolean_t  VirtioNetGetCapab(void *pvArg, mac_capab_t Capab, void *pvCapabData);
+static mblk_t    *VirtioNetXmit(void *pvArg, mblk_t *pMsg);
+static uint_t     VirtioNetISR(caddr_t addrArg);
+
+static int        VirtioNetAttachQueues(PVIRTIODEVICE pDevice);
+static void       VirtioNetDetachQueues(PVIRTIODEVICE pDevice);
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Device operations for Virtio Net.
+ */
+VIRTIODEVICEOPS g_VirtioDeviceOpsNet =
+{
+    VirtioNetDevAlloc,
+    VirtioNetDevFree,
+    VirtioNetDevAttach,
+    VirtioNetDevDetach
+};
+
+/**
+ * virtio_net_t: Private data per Virtio Device.
+ */
+typedef struct virtio_net_t
+{
+    mac_handle_t        hMac;           /* Handle to the MAC layer. */
+    RTMAC               MacAddr;        /* MAC address. */
+    PVIRTIOQUEUE        pRxQueue;       /* Receive Queue. */
+    PVIRTIOQUEUE        pTxQueue;       /* Xmit Queue. */
+    PVIRTIOQUEUE        pCtrlQueue;     /* Control Queue. */
+    kmem_cache_t       *pTxCache;       /* TX buffer cache. */
+} virtio_net_t;
+
+/**
+ * virtio_txbuf_t: Virtio Net TX buffer.
+ */
+typedef struct virtio_net_txbuf_t
+{
+    ddi_dma_handle_t    hDMA;           /* DMA TX handle. */
+} virtio_net_txbuf_t;
+
+/*
+ * virtio_net_header_t: Virtio Net TX/RX buffer header.
+ */
+typedef struct virtio_net_header_t
+{
+    uint8_t             u8Flags;        /* Flags. */
+    uint8_t             u8GSOType;      /* GSO type. */
+    uint16_t            u16HdrLen;      /* Length of this header. */
+    uint16_t            u16GSOSize;     /* GSO length if applicable. */
+    uint16_t            u16CSumStart;   /* Checksum start.*/
+    uint16_t            u16CSumOffset;  /* Checksum offset.*/
+} virtio_net_header_t;
+
+/**
+ * MAC layer hooks for VirtioNet.
+ */
+static mac_callbacks_t g_VirtioNetCallbacks =
+{
+    MC_GETCAPAB,                        /* Mask of available extra hooks. */
+    VirtioNetStat,
+    VirtioNetStart,
+    VirtioNetStop,
+    VirtioNetSetPromisc,
+    VirtioNetSetMulticast,
+    VirtioNetSetUnicast,
+    VirtioNetXmit,
+    NULL,                               /* Reserved. */
+    NULL,                               /* IOCtl. */
+    VirtioNetGetCapab,
+};
+
+/**
+ * DMA transfer attributes for Xmit/Recv. buffers.
+ */
+static ddi_dma_attr_t g_VirtioNetBufDmaAttr =
+{
+    DMA_ATTR_V0,                    /* Version. */
+    0,                              /* Lowest usable address. */
+    0xffffffffffffffffULL,          /* Highest usable address. */
+    0x7fffffff,                     /* Maximum DMAable byte count. */
+    MMU_PAGESIZE,                   /* Alignment in bytes. */
+    0x7ff,                          /* Bitmap of burst sizes */
+    1,                              /* Minimum transfer. */
+    0xffffffffU,                    /* Maximum transfer. */
+    0xffffffffffffffffULL,          /* Maximum segment length. */
+    1,                              /* Maximum number of segments. */
+    1,                              /* Granularity. */
+    0                               /* Flags (reserved). */
+};
+
+/**
+ * cb_ops: driver char/block entry points
+ */
+static struct cb_ops g_VirtioNetCbOps =
+{
+    nulldev,                        /* cb open */
+    nulldev,                        /* cb close */
+    nodev,                          /* b strategy */
+    nodev,                          /* b dump */
+    nodev,                          /* b print */
+    nodev,                          /* cb read */
+    nodev,                          /* cb write */
+    nodev,                          /* cb ioctl */
+    nodev,                          /* c devmap */
+    nodev,                          /* c mmap */
+    nodev,                          /* c segmap */
+    nochpoll,                       /* c poll */
+    ddi_prop_op,                    /* property ops */
+    NULL,                           /* streamtab */
+    D_MP,                           /* compat. flag */
+    CB_REV                          /* revision */
+};
+
+/**
+ * dev_ops: driver entry/exit and other ops.
+ */
+static struct dev_ops g_VirtioNetDevOps =
+{
+    DEVO_REV,                       /* driver build revision */
+    0,                              /* ref count */
+    NULL,                           /* get info */
+    nulldev,                        /* identify */
+    nulldev,                        /* probe */
+    VirtioNetAttach,
+    VirtioNetDetach,
+    nodev,                          /* reset */
+    &g_VirtioNetCbOps,
+    (struct bus_ops *)0,
+    nodev                           /* power */
+};
+
+/**
+ * modldrv: export driver specifics to kernel
+ */
+static struct modldrv g_VirtioNetDriver =
+{
+    &mod_driverops,                 /* extern from kernel */
+    DEVICE_DESC_DRV " " VBOX_VERSION_STRING "r"  RT_XSTR(VBOX_SVN_REV),
+    &g_VirtioNetDevOps
+};
+
+/**
+ * modlinkage: export install/remove/info to the kernel
+ */
+static struct modlinkage g_VirtioNetModLinkage =
+{
+    MODREV_1,                       /* loadable module system revision */
+    {
+        &g_VirtioNetDriver,         /* driver framework */
+        NULL                        /* terminate array of linkage structures */
+    }
+};
+
+
+/**
+ * Kernel entry points
+ */
+int _init(void)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":_init\n"));
+
+    /*
+     * Prevent module autounloading.
+     */
+    modctl_t *pModCtl = mod_getctl(&g_VirtioNetModLinkage);
+    if (pModCtl)
+        pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD;
+    else
+        LogRel((VIRTIOLOGNAME ":failed to disable autounloading!\n"));
+
+    /*
+     * Initialize IPRT.
+     */
+    int rc = RTR0Init(0);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Initialize Solaris specific globals here.
+         */
+        mac_init_ops(&g_VirtioNetDevOps, DEVICE_NAME);
+        rc = mod_install(&g_VirtioNetModLinkage);
+        if (!rc)
+            return rc;
+
+        LogRel((VIRTIOLOGNAME ":mod_install failed. rc=%d\n", rc));
+        mac_fini_ops(&g_VirtioNetDevOps);
+        RTR0Term();
+        return rc;
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":failed to initialize IPRT (rc=%d)\n", rc));
+
+    return RTErrConvertToErrno(rc);
+}
+
+
+int _fini(void)
+{
+    int rc;
+    LogFlowFunc((VIRTIOLOGNAME ":_fini\n"));
+
+    rc = mod_remove(&g_VirtioNetModLinkage);
+    if (!rc)
+    {
+        mac_fini_ops(&g_VirtioNetDevOps);
+        RTR0Term();
+    }
+    return rc;
+}
+
+
+int _info(struct modinfo *pModInfo)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":_info\n"));
+
+    int rc = mod_info(&g_VirtioNetModLinkage, pModInfo);
+
+    LogFlow((VIRTIOLOGNAME ":_info returns %d\n", rc));
+    return rc;
+}
+
+
+/**
+ * Attach entry point, to attach a device to the system or resume it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   Cmd             Operation type (attach/resume).
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetAttach(dev_info_t *pDip, ddi_attach_cmd_t Cmd)
+{
+    return VirtioAttach(pDip, Cmd, &g_VirtioDeviceOpsNet, &g_VirtioHyperOpsPci);
+}
+
+
+/**
+ * Detach entry point, to detach a device to the system or suspend it.
+ *
+ * @param   pDip            The module structure instance.
+ * @param   Cmd             Operation type (detach/suspend).
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetDetach(dev_info_t *pDip, ddi_detach_cmd_t Cmd)
+{
+    return VirtioDetach(pDip, Cmd);
+}
+
+
+/**
+ * Virtio Net TX buffer constructor for kmem_cache_create().
+ *
+ * @param pvBuf             Pointer to the allocated buffer.
+ * @param pvArg             Opaque private data.
+ * @param fFlags            Propagated KM flag values.
+ *
+ * @return 0 on success, or -1 on failure.
+ */
+static int VirtioNetTxBufCreate(void *pvBuf, void *pvArg, int fFlags)
+{
+    virtio_net_txbuf_t *pTxBuf = pvBuf;
+    PVIRTIODEVICE pDevice = pvArg;
+
+    /** @todo ncookies handles? */
+    int rc = ddi_dma_alloc_handle(pDevice->pDip, &g_VirtioNetBufDmaAttr,
+                                  fFlags & KM_NOSLEEP ? DDI_DMA_DONTWAIT : DDI_DMA_SLEEP,
+                                  0 /* Arg */, &pTxBuf->hDMA);
+    if (rc == DDI_SUCCESS)
+        return 0;
+    return -1;
+}
+
+
+/**
+ * Virtio Net TX buffer destructor for kmem_cache_create().
+ *
+ * @param pvBuf             Pointer to the allocated buffer.
+ * @param pvArg
+ */
+static void VirtioNetTxBufDestroy(void *pvBuf, void *pvArg)
+{
+    NOREF(pvArg);
+    virtio_net_txbuf_t *pTxBuf = pvBuf;
+
+    ddi_dma_free_handle(&pTxBuf->hDMA);
+}
+
+
+/**
+ * Virtio Net private data allocation routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return Allocated private data that must only be freed by calling
+ *         VirtioNetDevFree().
+ */
+static void *VirtioNetDevAlloc(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetDevAlloc pDevice=%p\n", pDevice));
+
+    AssertReturn(pDevice, NULL);
+    virtio_net_t *pNet = RTMemAllocZ(sizeof(virtio_net_t));
+    if (RT_LIKELY(pNet))
+    {
+        /*
+         * Create a kernel memory cache for frequently allocated/deallocated
+         * buffers.
+         */
+        char szCachename[KSTAT_STRLEN];
+        RTStrPrintf(szCachename, sizeof(szCachename), "VirtioNet_Cache_%d", ddi_get_instance(pDevice->pDip));
+        pNet->pTxCache = kmem_cache_create(szCachename,                /* Cache name */
+                                           sizeof(virtio_net_txbuf_t), /* Size of buffers in cache */
+                                           0,                          /* Align */
+                                           VirtioNetTxBufCreate,       /* Buffer constructor */
+                                           VirtioNetTxBufDestroy,      /* Buffer destructor */
+                                           NULL,                       /* pfnReclaim */
+                                           pDevice,                    /* Private data */
+                                           NULL,                       /* "vmp", MBZ (man page) */
+                                           0                           /* "cflags", MBZ (man page) */
+                                           );
+        if (RT_LIKELY(pNet->pTxCache))
+            return pNet;
+        else
+            LogRel((VIRTIOLOGNAME ":kmem_cache_create failed.\n"));
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":failed to alloc %u bytes for Net instance.\n", sizeof(virtio_net_t)));
+
+    return NULL;
+}
+
+
+/**
+ * Virtio Net private data free routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ */
+static void VirtioNetDevFree(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetDevFree pDevice=%p\n", pDevice));
+    AssertReturnVoid(pDevice);
+
+    virtio_net_t *pNet = pDevice->pvDevice;
+    kmem_cache_destroy(pNet->pTxCache);
+    RTMemFree(pNet);
+    pDevice->pvDevice = NULL;
+}
+
+
+/**
+ * Virtio Net device attach rountine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetDevAttach(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetDevAttach pDevice=%p\n", pDevice));
+
+    virtio_net_t *pNet = pDevice->pvDevice;
+    mac_register_t *pMacRegHandle = mac_alloc(MAC_VERSION);
+    if (pMacRegHandle)
+    {
+        pMacRegHandle->m_driver     = pDevice;
+        pMacRegHandle->m_dip        = pDevice->pDip;
+        pMacRegHandle->m_callbacks  = &g_VirtioNetCallbacks;
+        pMacRegHandle->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
+        pMacRegHandle->m_min_sdu    = 0;
+        pMacRegHandle->m_max_sdu    = 1500;    /** @todo verify */
+        /** @todo should we set the margin size? */
+        pMacRegHandle->m_src_addr   = pNet->MacAddr.au8;
+
+        /*
+         * Get MAC from the host or generate a random MAC address.
+         */
+        if (pDevice->fHostFeatures & VIRTIO_NET_MAC)
+        {
+            pDevice->pHyperOps->pfnGet(pDevice, 0 /* offset */, &pNet->MacAddr.au8, sizeof(pNet->MacAddr));
+            LogFlow((VIRTIOLOGNAME ":VirtioNetDevAttach: Obtained MAC address from host: %.6Rhxs\n", pNet->MacAddr.au8));
+        }
+        else
+        {
+            pNet->MacAddr.au8[0] = 0x08;
+            pNet->MacAddr.au8[1] = 0x00;
+            pNet->MacAddr.au8[2] = 0x27;
+            RTRandBytes(&pNet->MacAddr.au8[3], 3);
+            LogFlow((VIRTIOLOGNAME ":VirtioNetDevAttach: Generated MAC address %.6Rhxs\n", pNet->MacAddr.au8));
+        }
+
+        int rc = VirtioNetAttachQueues(pDevice);
+        if (rc == DDI_SUCCESS)
+        {
+            rc = mac_register(pMacRegHandle, &pNet->hMac);
+            if (rc == 0)
+            {
+                mac_link_update(pNet->hMac, LINK_STATE_DOWN);
+                mac_free(pMacRegHandle);
+                LogFlow((VIRTIOLOGNAME ":VirtioNetDevAttach: successfully registered mac.\n"));
+                return DDI_SUCCESS;
+            }
+            else
+                LogRel((VIRTIOLOGNAME ":VirtioNetDevAttach: mac_register failed. rc=%d\n", rc));
+
+            VirtioNetDetachQueues(pDevice);
+        }
+        else
+            LogRel((VIRTIOLOGNAME ":VirtioNetDevAttach: VirtioNetAttachQueues failed. rc=%d\n", rc));
+
+        mac_free(pMacRegHandle);
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioNetDevAttach: mac_alloc failed. Invalid version!?!\n"));
+
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Virtio Net device detach routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetDevDetach(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetDevDetach pDevice=%p\n", pDevice));
+    virtio_net_t *pNet = pDevice->pvDevice;
+
+    int rc = mac_unregister(pNet->hMac);
+    if (rc == 0)
+    {
+        VirtioNetDetachQueues(pDevice);
+        return DDI_SUCCESS;
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioNetDevDetach: mac_unregister failed. rc=%d\n", rc));
+
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Attach the Virtio Net TX, RX and control queues.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetAttachQueues(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetAttachQueues pDevice=%p\n", pDevice));
+
+    virtio_net_t *pNet = pDevice->pvDevice;
+
+    pNet->pRxQueue = VirtioGetQueue(pDevice, 0 /* index */ );
+    if (pNet->pRxQueue)
+    {
+        pNet->pTxQueue = VirtioGetQueue(pDevice, 1 /* index */);
+        if (pNet->pTxQueue)
+        {
+            if (pDevice->fHostFeatures & VIRTIO_NET_CTRL_VQ)
+            {
+                pNet->pCtrlQueue = VirtioGetQueue(pDevice, 2 /* index */);
+                if (pNet->pCtrlQueue)
+                {
+                    LogFlow((VIRTIOLOGNAME ":VirtioNetAttachQueues successfully obtained 3 queues.\n"));
+                    return DDI_SUCCESS;
+                }
+                else
+                    LogRel((VIRTIOLOGNAME ":VirtioNetAttachQueues: failed to get Control queue.\n"));
+            }
+            else
+            {
+                LogFlow((VIRTIOLOGNAME ":VirtioNetAttachQueues successfully obtained 2 queues.\n"));
+                return DDI_SUCCESS;
+            }
+
+            VirtioPutQueue(pDevice, pNet->pTxQueue);
+            pNet->pTxQueue = NULL;
+        }
+        else
+            LogRel((VIRTIOLOGNAME ":VirtioNetAttachQueues: failed to get TX queue.\n"));
+
+        VirtioPutQueue(pDevice, pNet->pRxQueue);
+        pNet->pRxQueue = NULL;
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioNetAttachQueues: failed to get RX queue.\n"));
+
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Detach the Virtio Net TX, RX and control queues.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ */
+static void VirtioNetDetachQueues(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetDetachQueues pDevice=%p\n", pDevice));
+    virtio_net_t *pNet = pDevice->pvDevice;
+
+    if (   pDevice->fHostFeatures & VIRTIO_NET_CTRL_VQ
+        && pNet->pCtrlQueue)
+        VirtioPutQueue(pDevice, pNet->pCtrlQueue);
+
+    if (pNet->pTxCache)
+        VirtioPutQueue(pDevice, pNet->pTxQueue);
+
+    if (pNet->pRxQueue)
+        VirtioPutQueue(pDevice, pNet->pRxQueue);
+}
+
+
+
+/* -=-=-=-=- Virtio Net MAC layer callbacks  -=-=-=-=- */
+
+/**
+ * Virtio Net statistics.
+ *
+ * @param pvArg             Pointer to private data.
+ * @param cmdStat           Which statistics to provide.
+ * @param pu64Val           Where to write statistics data.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetStat(void *pvArg, uint_t cmdStat, uint64_t *pu64Val)
+{
+    NOREF(pvArg);
+    NOREF(cmdStat);
+    NOREF(pu64Val);
+    return ENOTSUP;
+}
+
+
+/**
+ * Virtio Net Start.
+ *
+ * @param pvArg             Pointer to private data.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetStart(void *pvArg)
+{
+    PVIRTIODEVICE pDevice = pvArg;
+    virtio_net_t *pNet = pDevice->pvDevice;
+    mac_link_update(pNet->hMac, LINK_STATE_UP);
+
+    pDevice->pHyperOps->pfnSetStatus(pDevice, VIRTIO_PCI_STATUS_DRV_OK);
+    return 0;
+}
+
+
+/**
+ * Virtio Net Stop.
+ *
+ * @param pvArg             Pointer to private data.
+ */
+static void VirtioNetStop(void *pvArg)
+{
+    PVIRTIODEVICE pDevice = pvArg;
+    virtio_net_t *pNet = pDevice->pvDevice;
+    mac_link_update(pNet->hMac, LINK_STATE_DOWN);
+
+    /*
+     * I don't think we should set status here as the host checks the status on every Xmit. This means pending Xmits
+     * would also be dropped.
+     * @todo: Not sure what's the best way to signal connect/disconnect of the link to the host. Figure it out.
+     */
+}
+
+
+/**
+ * Virtio Net toggle Promiscuous mode.
+ *
+ * @param pvArg             Pointer to private data.
+ * @param fPromiscOn        Promiscuous On/Off.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetSetPromisc(void *pvArg, boolean_t fPromiscOn)
+{
+    NOREF(pvArg);
+    NOREF(fPromiscOn);
+    return 0;
+}
+
+
+/**
+ * Virtio Net set/add multicast address.
+ *
+ * @param pvArg             Pointer to private data.
+ * @param fAdd              Whether to add multicast address or not.
+ * @param pbMac             Pointer to the multicast MAC address to set/add.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetSetMulticast(void *pvArg, boolean_t fAdd, const uint8_t *pbMac)
+{
+    NOREF(pvArg);
+    NOREF(fAdd);
+    NOREF(pbMac);
+    return 1;
+}
+
+
+/**
+ * Virtio Net set unicast address.
+ *
+ * @param pvArg             Pointer to private data.
+ * @param pbMac             Pointer to the unicast MAC address to set.
+ *
+ * @return corresponding solaris error code.
+ */
+static int VirtioNetSetUnicast(void *pvArg, const uint8_t *pbMac)
+{
+    NOREF(pvArg);
+    NOREF(pbMac);
+    return ENOTSUP;
+}
+
+
+/**
+ * Virtio Net get capabilities hook.
+ *
+ * @param pvArg             Pointer to private data.
+ * @param Capab             MAC layer capabilities.
+ * @param pvCapabData       Pointer to store capability info.
+ *
+ * @return B_TRUE upon success, otherwise B_FALSE.
+ */
+static boolean_t VirtioNetGetCapab(void *pvArg, mac_capab_t Capab, void *pvCapabData)
+{
+    NOREF(pvArg);
+    NOREF(Capab);
+    NOREF(pvCapabData);
+    return B_FALSE;
+}
+
+
+/**
+ * Virtio Net Xmit hook.
+ *
+ * @param pvArg             Pointer to private data.
+ * @param pMsg              Pointer to the message.
+ *
+ * @return Pointer to message not Xmited.
+ */
+static mblk_t *VirtioNetXmit(void *pvArg, mblk_t *pMsg)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioNetXmit pMsg=%p\n", pMsg));
+    cmn_err(CE_NOTE, "Xmit pMsg=%p\n", pMsg);
+
+    PVIRTIODEVICE pDevice = pvArg;
+    virtio_net_t *pNet    = pDevice->pvDevice;
+    bool fNotify          = false;
+
+    while (pMsg)
+    {
+        mblk_t *pNextMsg = pMsg->b_next;
+
+#if 0
+        mblk_t *pHdr = allocb(sizeof(virtio_net_header_t), BPRI_HI);
+        if (RT_UNLIKELY(!pHdr))
+            break;
+
+        virtio_net_header_t *pNetHdr = pHdr->b_rptr;
+        memset(pNetHdr, 0, sizeof(virtio_net_header_t));
+        pNetHdr->u8Flags       = VIRTIO_NET_GUEST_CSUM;
+        pNetHdr->u16HdrLen     = sizeof(virtio_net_header_t);
+
+        pHdr->b_wptr += sizeof(virtio_net_header_t);
+        pHdr->b_cont = pMsg;
+#endif
+
+        virtio_net_txbuf_t *pTxBuf = kmem_cache_alloc(pNet->pTxCache, KM_SLEEP);
+        if (!pTxBuf)
+            break;
+
+        ddi_dma_cookie_t DmaCookie;
+        uint_t cCookies;
+        int rc = ddi_dma_addr_bind_handle(pTxBuf->hDMA, NULL /* addrspace */, (char *)pMsg->b_rptr, MBLKL(pMsg),
+                                          DDI_DMA_WRITE | DDI_DMA_STREAMING, DDI_DMA_SLEEP, 0 /* addr */,
+                                          &DmaCookie, &cCookies);
+        cmn_err(CE_NOTE, "VirtioNetXmit: MBLKL pMsg=%u\n", MBLKL(pMsg));
+        if (rc != DDI_DMA_MAPPED)
+        {
+            LogRel((VIRTIOLOGNAME ":VirtioNetXmit failed to map address to DMA handle. rc=%d\n", rc));
+            kmem_cache_free(pNet->pTxCache, pTxBuf);
+            break;
+        }
+
+        /** @todo get 'cCookies' slots from the ring. */
+
+        for (uint_t i = 0; i < cCookies; i++)
+        {
+            uint16_t fFlags = 0;
+            if (i < cCookies - 1)
+                fFlags |= VIRTIO_FLAGS_RING_DESC_NEXT;
+
+            rc = VirtioRingPush(pNet->pTxQueue, DmaCookie.dmac_laddress, DmaCookie.dmac_size, fFlags);
+            if (RT_FAILURE(rc))
+            {
+                LogRel((VIRTIOLOGNAME ":VirtioNetXmit failed. rc=%Rrc\n", rc));
+                break;
+            }
+
+            ddi_dma_nextcookie(pTxBuf->hDMA, &DmaCookie);
+        }
+
+        pMsg = pNextMsg;
+        fNotify = true;
+        if (RT_FAILURE(rc))
+        {
+            ddi_dma_unbind_handle(pTxBuf->hDMA);
+            break;
+        }
+    }
+
+    if (fNotify)
+        pDevice->pHyperOps->pfnNotifyQueue(pDevice, pNet->pTxQueue);
+
+    return pMsg;
+}
+
+
+/**
+ * Interrupt Service Routine for Virtio Net.
+ *
+ * @param   Arg     Private data (unused, will be NULL).
+ * @returns DDI_INTR_CLAIMED if it's our interrupt, DDI_INTR_UNCLAIMED if it isn't.
+ */
+static uint_t VirtioNetISR(caddr_t Arg)
+{
+    cmn_err(CE_NOTE, "VirtioNetISR Arg=%p\n", Arg);
+    NOREF(Arg);
+    return DDI_INTR_UNCLAIMED;
+}
+
diff --git a/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.c b/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.c
new file mode 100644
index 00000000..6c8f0ec3
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.c
@@ -0,0 +1,655 @@
+/* $Id: VirtioPci-solaris.c $ */
+/** @file
+ * VirtualBox Guest Additions - Virtio Driver for Solaris, PCI Hypervisor Interface.
+ */
+
+/*
+ * Copyright (C) 2010-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "VirtioPci-solaris.h"
+
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/mem.h>
+#include <iprt/param.h>
+#include <VBox/log.h>
+
+#include <sys/pci.h>
+#include <sys/param.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/*
+ * Pci Register offsets.
+ */
+#define VIRTIO_PCI_HOST_FEATURES            0x00
+#define VIRTIO_PCI_GUEST_FEATURES           0x04
+#define VIRTIO_PCI_QUEUE_PFN                0x08
+#define VIRTIO_PCI_QUEUE_NUM                0x0C
+#define VIRTIO_PCI_QUEUE_SEL                0x0E
+#define VIRTIO_PCI_QUEUE_NOTIFY             0x10
+#define VIRTIO_PCI_STATUS                   0x12
+#define VIRTIO_PCI_ISR                      0x13
+#define VIRTIO_PCI_CONFIG                   0x14
+
+#define VIRTIO_PCI_RING_ALIGN               PAGE_SIZE
+#define VIRTIO_PCI_QUEUE_ADDR_SHIFT         PAGE_SHIFT
+
+/**
+ * virtio_pci_t: Private data per device instance.
+ */
+typedef struct virtio_pci_t
+{
+    ddi_acc_handle_t    hIO;            /* IO handle */
+    caddr_t             addrIOBase;     /* IO base address */
+} virtio_pci_t;
+
+/**
+ * virtio_pci_queue_t: Private data per queue instance.
+ */
+typedef struct virtio_pci_queue_t
+{
+    ddi_dma_handle_t    hDMA;           /* DMA handle. */
+    ddi_acc_handle_t    hIO;            /* IO handle. */
+    size_t              cbBuf;          /* Physical address of buffer. */
+    paddr_t             physBuf;        /* Size of buffer. */
+    pfn_t               pageBuf;        /* Page frame number of buffer. */
+} virtio_pci_queue_t;
+
+static ddi_device_acc_attr_t g_VirtioPciAccAttrRegs =
+{
+    DDI_DEVICE_ATTR_V0,                 /* Version */
+    DDI_STRUCTURE_LE_ACC,               /* Structural data access in little endian. */
+    DDI_STRICTORDER_ACC,                /* Strict ordering. */
+    DDI_DEFAULT_ACC                     /* Default access, possible panic on errors*/
+};
+
+static ddi_device_acc_attr_t g_VirtioPciAccAttrRing =
+{
+    DDI_DEVICE_ATTR_V0,                 /* Version. */
+    DDI_NEVERSWAP_ACC,                  /* Data access with no byte swapping*/
+    DDI_STRICTORDER_ACC,                /* Strict ordering. */
+    DDI_DEFAULT_ACC                     /* Default access, possible panic on errors*/
+};
+
+static ddi_dma_attr_t g_VirtioPciDmaAttrRing =
+{
+    DMA_ATTR_V0,                        /* Version. */
+    0,                                  /* Lowest usable address. */
+    0xffffffffffffffffULL,              /* Highest usable address. */
+    0x7fffffff,                         /* Maximum DMAable byte count. */
+    VIRTIO_PCI_RING_ALIGN,              /* Alignment in bytes. */
+    0x7ff,                              /* Bitmap of burst sizes */
+    1,                                  /* Minimum transfer. */
+    0xffffffffU,                        /* Maximum transfer. */
+    0xffffffffffffffffULL,              /* Maximum segment length. */
+    1,                                  /* Maximum number of segments. */
+    1,                                  /* Granularity. */
+    0                                   /* Flags (reserved). */
+};
+
+/** Pointer to the interrupt handle vector */
+static ddi_intr_handle_t   *g_pIntr;
+/** Number of actually allocated interrupt handles */
+static size_t               g_cIntrAllocated;
+/** The IRQ Mutex */
+static kmutex_t             g_IrqMtx;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static void    *VirtioPciAlloc(PVIRTIODEVICE pDevice);
+static void     VirtioPciFree(PVIRTIODEVICE pDevice);
+static int      VirtioPciAttach(PVIRTIODEVICE pDevice);
+static int      VirtioPciDetach(PVIRTIODEVICE pDevice);
+static uint32_t VirtioPciGetFeatures(PVIRTIODEVICE pDevice);
+static void     VirtioPciSetFeatures(PVIRTIODEVICE pDevice, uint32_t fFeatures);
+static int      VirtioPciNotifyQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
+static void     VirtioPciGet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb);
+static void     VirtioPciSet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb);
+static void    *VirtioPciGetQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
+static void     VirtioPciPutQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue);
+static void     VirtioPciSetStatus(PVIRTIODEVICE pDevice, uint8_t Status);
+
+static uint_t   VirtioPciISR(caddr_t Arg);
+static int      VirtioPciSetupIRQ(dev_info_t *pDip);
+static void     VirtioPciRemoveIRQ(dev_info_t *pDip);
+
+/**
+ * Hypervisor operations for Virtio Pci.
+ */
+VIRTIOHYPEROPS g_VirtioHyperOpsPci =
+{
+    VirtioPciAlloc,
+    VirtioPciFree,
+    VirtioPciAttach,
+    VirtioPciDetach,
+    VirtioPciGetFeatures,
+    VirtioPciSetFeatures,
+    VirtioPciNotifyQueue,
+    VirtioPciGet,
+    VirtioPciSet,
+    VirtioPciGetQueue,
+    VirtioPciPutQueue,
+    VirtioPciSetStatus
+};
+
+
+/**
+ * Virtio Pci private data allocation routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @return Allocated private data structure which must only be freed by calling
+ *         VirtioPciFree().
+ */
+static void *VirtioPciAlloc(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciAlloc pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = RTMemAllocZ(sizeof(virtio_pci_t));
+    return pPciData;
+}
+
+
+/**
+ * Virtio Pci private data deallocation routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ */
+static void VirtioPciFree(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciFree pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    if (pPciData)
+    {
+        RTMemFree(pDevice->pvHyper);
+        pDevice->pvHyper = NULL;
+    }
+}
+
+
+/**
+ * Virtio Pci attach routine, called from driver attach.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
+ */
+static int VirtioPciAttach(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciAttach pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturn(pPciData, DDI_FAILURE);
+
+    int rc = ddi_regs_map_setup(pDevice->pDip,
+                                1,                       /* reg. num */
+                                &pPciData->addrIOBase,
+                                0,                       /* offset */
+                                0,                       /* length */
+                                &g_VirtioPciAccAttrRegs,
+                                &pPciData->hIO);
+    if (rc == DDI_SUCCESS)
+    {
+        /*
+         * Reset the device.
+         */
+        VirtioPciSetStatus(pDevice, 0);
+
+        /*
+         * Add interrupt handler.
+         */
+        VirtioPciSetupIRQ(pDevice->pDip);
+
+        LogFlow((VIRTIOLOGNAME ":VirtioPciAttach: successfully mapped registers.\n"));
+        return DDI_SUCCESS;
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioPciAttach: ddi_regs_map_setup failed. rc=%d\n", rc));
+    return DDI_FAILURE;
+}
+
+
+/**
+ * Virtio Pci detach routine, called from driver detach.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
+ */
+static int VirtioPciDetach(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciDetach pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturn(pPciData, DDI_FAILURE);
+
+    VirtioPciRemoveIRQ(pDevice->pDip);
+    ddi_regs_map_free(&pPciData->hIO);
+    return DDI_SUCCESS;
+}
+
+
+/**
+ * Get host supported features.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ *
+ * @return Mask of host features.
+ */
+static uint32_t VirtioPciGetFeatures(PVIRTIODEVICE pDevice)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciGetFeatures pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturn(pPciData, 0);
+
+    return ddi_get32(pPciData->hIO, (uint32_t *)(pPciData->addrIOBase + VIRTIO_PCI_HOST_FEATURES));
+}
+
+
+/**
+ * Set guest supported features.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param u32Features       Mask of guest supported features.
+ */
+static void VirtioPciSetFeatures(PVIRTIODEVICE pDevice, uint32_t u32Features)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciSetFeatures pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturnVoid(pPciData);
+
+    ddi_put32(pPciData->hIO, (uint32_t *)(pPciData->addrIOBase + VIRTIO_PCI_GUEST_FEATURES), u32Features);
+}
+
+
+/**
+ * Update the queue, notify the host.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param pQueue            Pointer to the Queue that is doing the notification.
+ *
+ * @return Solaris DDI error code. DDI_SUCCESS or DDI_FAILURE.
+ */
+static int VirtioPciNotifyQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciNotifyQueue pDevice=%p pQueue=%p\n", pDevice, pQueue));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturn(pPciData, DDI_FAILURE);
+
+    pQueue->Ring.pRingAvail->Index += pQueue->cBufs;
+    pQueue->cBufs = 0;
+
+    ASMCompilerBarrier();
+
+    ddi_put16(pPciData->hIO, (uint16_t *)(pPciData->addrIOBase + VIRTIO_PCI_QUEUE_NOTIFY), pQueue->QueueIndex);
+    cmn_err(CE_NOTE, "VirtioPciNotifyQueue\n");
+}
+
+
+
+/**
+ * Virtio Pci set (write) routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param off               Offset into the PCI config space.
+ * @param pv                Pointer to the buffer to write from.
+ * @param cb                Size of the buffer in bytes.
+ */
+static void VirtioPciSet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciSet pDevice=%p\n", pDevice));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturnVoid(pPciData);
+
+    uint8_t *pb = pv;
+    for (size_t i = 0; i < cb; i++, pb++)
+        ddi_put8(pPciData->hIO, (uint8_t *)(pPciData->addrIOBase + VIRTIO_PCI_CONFIG + off + i), *pb);
+}
+
+
+/**
+ * Virtio Pci get (read) routine.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param off               Offset into the PCI config space.
+ * @param pv                Where to store the read data.
+ * @param cb                Size of the buffer in bytes.
+ */
+static void VirtioPciGet(PVIRTIODEVICE pDevice, off_t off, void *pv, size_t cb)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciGet pDevice=%p off=%u pv=%p cb=%u\n", pDevice, off, pv, cb));
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    AssertReturnVoid(pPciData);
+
+    uint8_t *pb = pv;
+    for (size_t i = 0; i < cb; i++, pb++)
+        *pb = ddi_get8(pPciData->hIO, (uint8_t *)(pPciData->addrIOBase + VIRTIO_PCI_CONFIG + off + i));
+}
+
+
+/**
+ * Virtio Pci put queue routine. Places the queue and frees associated queue.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param pQueue            Pointer to the queue.
+ */
+static void VirtioPciPutQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciPutQueue pDevice=%p pQueue=%p\n", pDevice, pQueue));
+    AssertReturnVoid(pDevice);
+    AssertReturnVoid(pQueue);
+
+    virtio_pci_t *pPci = pDevice->pvHyper;
+    AssertReturnVoid(pPci);
+    virtio_pci_queue_t *pPciQueue = pQueue->pvData;
+    if (RT_UNLIKELY(!pPciQueue))
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioPciPutQueue missing Pci queue.\n"));
+        return;
+    }
+
+    ddi_put16(pPci->hIO, (uint16_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_SEL), pQueue->QueueIndex);
+    ddi_put32(pPci->hIO, (uint32_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_PFN), 0);
+
+    ddi_dma_unbind_handle(pPciQueue->hDMA);
+    ddi_dma_mem_free(&pPciQueue->hIO);
+    ddi_dma_free_handle(&pPciQueue->hDMA);
+    RTMemFree(pPciQueue);
+}
+
+
+/**
+ * Virtio Pci get queue routine. Allocates a PCI queue and DMA resources.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param pQueue            Where to store the queue.
+ *
+ * @return An allocated Virtio Pci queue, or NULL in case of errors.
+ */
+static void *VirtioPciGetQueue(PVIRTIODEVICE pDevice, PVIRTIOQUEUE pQueue)
+{
+    LogFlowFunc((VIRTIOLOGNAME ":VirtioPciGetQueue pDevice=%p pQueue=%p\n", pDevice, pQueue));
+    AssertReturn(pDevice, NULL);
+
+    virtio_pci_t *pPci = pDevice->pvHyper;
+    AssertReturn(pPci, NULL);
+
+    /*
+     * Select a Queue.
+     */
+    ddi_put16(pPci->hIO, (uint16_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_SEL), pQueue->QueueIndex);
+
+    /*
+     * Get the currently selected Queue's size.
+     */
+    pQueue->Ring.cDesc = ddi_get16(pPci->hIO, (uint16_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_NUM));
+    if (RT_UNLIKELY(!pQueue->Ring.cDesc))
+    {
+        LogRel((VIRTIOLOGNAME ": VirtioPciGetQueue: Queue[%d] has no descriptors.\n", pQueue->QueueIndex));
+        return NULL;
+    }
+
+    /*
+     * Check if it's already active.
+     */
+    uint32_t QueuePFN = ddi_get32(pPci->hIO, (uint32_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_PFN));
+    if (QueuePFN != 0)
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: Queue[%d] is already used.\n", pQueue->QueueIndex));
+        return NULL;
+    }
+
+    LogFlow(("Queue[%d] has %d slots.\n", pQueue->QueueIndex, pQueue->Ring.cDesc));
+
+    /*
+     * Allocate and initialize Pci queue data.
+     */
+    virtio_pci_queue_t *pPciQueue = RTMemAllocZ(sizeof(virtio_pci_queue_t));
+    if (pPciQueue)
+    {
+        /*
+         * Setup DMA.
+         */
+        size_t cbQueue = VirtioRingSize(pQueue->Ring.cDesc, VIRTIO_PCI_RING_ALIGN);
+        int rc = ddi_dma_alloc_handle(pDevice->pDip, &g_VirtioPciDmaAttrRing, DDI_DMA_SLEEP, 0 /* addr */, &pPciQueue->hDMA);
+        if (rc == DDI_SUCCESS)
+        {
+            rc = ddi_dma_mem_alloc(pPciQueue->hDMA, cbQueue, &g_VirtioPciAccAttrRing, DDI_DMA_CONSISTENT,
+                                   DDI_DMA_SLEEP, 0 /* addr */, &pQueue->pQueue, &pPciQueue->cbBuf,
+                                   &pPciQueue->hIO);
+            if (rc == DDI_SUCCESS)
+            {
+                AssertRelease(pPciQueue->cbBuf >= cbQueue);
+                ddi_dma_cookie_t DmaCookie;
+                uint_t cCookies;
+                rc = ddi_dma_addr_bind_handle(pPciQueue->hDMA, NULL /* addrspace */, pQueue->pQueue, pPciQueue->cbBuf,
+                                              DDI_DMA_RDWR | DDI_DMA_CONSISTENT, DDI_DMA_SLEEP,
+                                              0 /* addr */, &DmaCookie, &cCookies);
+                if (rc == DDI_SUCCESS)
+                {
+                    pPciQueue->physBuf = DmaCookie.dmac_laddress;
+                    pPciQueue->pageBuf = pPciQueue->physBuf >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
+
+                    LogFlow((VIRTIOLOGNAME ":VirtioPciGetQueue: Queue[%d]%p physBuf=%x pfn of Buf %#x\n", pQueue->QueueIndex,
+                             pQueue->pQueue, pPciQueue->physBuf, pPciQueue->pageBuf));
+                    cmn_err(CE_NOTE, ":VirtioPciGetQueue: Queue[%d]%p physBuf=%x pfn of Buf %x\n", pQueue->QueueIndex,
+                             pQueue->pQueue, pPciQueue->physBuf, pPciQueue->pageBuf);
+
+                    /*
+                     * Activate the queue and initialize a ring for the queue.
+                     */
+                    memset(pQueue->pQueue, 0, pPciQueue->cbBuf);
+                    ddi_put32(pPci->hIO, (uint32_t *)(pPci->addrIOBase + VIRTIO_PCI_QUEUE_PFN), pPciQueue->pageBuf);
+                    VirtioRingInit(pQueue, pQueue->Ring.cDesc, pQueue->pQueue, VIRTIO_PCI_RING_ALIGN);
+                    return pPciQueue;
+                }
+                else
+                    LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: ddi_dma_addr_bind_handle failed. rc=%d\n", rc));
+
+                ddi_dma_mem_free(&pPciQueue->hIO);
+            }
+            else
+                LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: ddi_dma_mem_alloc failed for %u bytes rc=%d\n", cbQueue, rc));
+
+            ddi_dma_free_handle(&pPciQueue->hDMA);
+        }
+        else
+            LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: ddi_dma_alloc_handle failed. rc=%d\n", rc));
+
+        RTMemFree(pPciQueue);
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioPciGetQueue: failed to alloc %u bytes for Pci Queue data.\n", sizeof(virtio_pci_queue_t)));
+
+    return NULL;
+}
+
+
+/**
+ * Set the Virtio PCI status bit.
+ *
+ * @param pDevice           Pointer to the Virtio device instance.
+ * @param Status            The status to set.
+ */
+static void VirtioPciSetStatus(PVIRTIODEVICE pDevice, uint8_t Status)
+{
+    virtio_pci_t *pPciData = pDevice->pvHyper;
+    ddi_put8(pPciData->hIO, (uint8_t *)(pPciData->addrIOBase + VIRTIO_PCI_STATUS), Status);
+}
+
+
+/**
+ * Sets up IRQ for Virtio PCI.
+ *
+ * @param   pDip     Pointer to the device info structure.
+ *
+ * @return Solaris error code.
+ */
+static int VirtioPciSetupIRQ(dev_info_t *pDip)
+{
+    LogFlow((VIRTIOLOGNAME ":VirtioPciSetupIRQ: pDip=%p\n", pDip));
+    cmn_err(CE_NOTE, "VirtioPciSetupIRQ\n");
+
+    int IntrType = 0;
+    int rc = ddi_intr_get_supported_types(pDip, &IntrType);
+    if (rc == DDI_SUCCESS)
+    {
+        /* We won't need to bother about MSIs. */
+        if (IntrType & DDI_INTR_TYPE_FIXED)
+        {
+            int IntrCount = 0;
+            rc = ddi_intr_get_nintrs(pDip, IntrType, &IntrCount);
+            if (   rc == DDI_SUCCESS
+                && IntrCount > 0)
+            {
+                int IntrAvail = 0;
+                rc = ddi_intr_get_navail(pDip, IntrType, &IntrAvail);
+                if (   rc == DDI_SUCCESS
+                    && IntrAvail > 0)
+                {
+                    /* Allocated kernel memory for the interrupt handles. The allocation size is stored internally. */
+                    g_pIntr = RTMemAllocZ(IntrCount * sizeof(ddi_intr_handle_t));
+                    if (g_pIntr)
+                    {
+                        int IntrAllocated;
+                        rc = ddi_intr_alloc(pDip, g_pIntr, IntrType, 0, IntrCount, &IntrAllocated, DDI_INTR_ALLOC_NORMAL);
+                        if (   rc == DDI_SUCCESS
+                            && IntrAllocated > 0)
+                        {
+                            g_cIntrAllocated = IntrAllocated;
+                            uint_t uIntrPriority;
+                            rc = ddi_intr_get_pri(g_pIntr[0], &uIntrPriority);
+                            if (rc == DDI_SUCCESS)
+                            {
+                                /* Initialize the mutex. */
+                                mutex_init(&g_IrqMtx, NULL, MUTEX_DRIVER, DDI_INTR_PRI(uIntrPriority));
+
+                                /* Assign interrupt handler functions and enable interrupts. */
+                                for (int i = 0; i < IntrAllocated; i++)
+                                {
+                                    rc = ddi_intr_add_handler(g_pIntr[i], (ddi_intr_handler_t *)VirtioPciISR,
+                                                            NULL /* No Private Data */, NULL);
+                                    if (rc == DDI_SUCCESS)
+                                        rc = ddi_intr_enable(g_pIntr[i]);
+                                    if (rc != DDI_SUCCESS)
+                                    {
+                                        /* Changing local IntrAllocated to hold so-far allocated handles for freeing. */
+                                        IntrAllocated = i;
+                                        break;
+                                    }
+                                }
+                                if (rc == DDI_SUCCESS)
+                                {
+                                    cmn_err(CE_NOTE, "VirtioPciSetupIRQ success\n");
+                                    return rc;
+                                }
+
+                                /* Remove any assigned handlers */
+                                LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ failed to assign IRQs allocated=%d\n", IntrAllocated));
+                                for (int x = 0; x < IntrAllocated; x++)
+                                    ddi_intr_remove_handler(g_pIntr[x]);
+                            }
+                            else
+                                LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ failed to get priority of interrupt. rc=%d\n", rc));
+
+                            /* Remove allocated IRQs, too bad we can free only one handle at a time. */
+                            for (int k = 0; k < g_cIntrAllocated; k++)
+                                ddi_intr_free(g_pIntr[k]);
+                        }
+                        else
+                            LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to allocated IRQs. count=%d\n", IntrCount));
+                        RTMemFree(g_pIntr);
+                    }
+                    else
+                        LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to allocated IRQs. count=%d\n", IntrCount));
+                }
+                else
+                {
+                    LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to get or insufficient available IRQs. rc=%d IntrAvail=%d\n",
+                            rc, IntrAvail));
+                }
+            }
+            else
+            {
+                LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to get or insufficient number of IRQs. rc=%d IntrCount=%d\n", rc,
+                        IntrCount));
+            }
+        }
+        else
+            LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: invalid irq type. IntrType=%#x\n", IntrType));
+    }
+    else
+        LogRel((VIRTIOLOGNAME ":VirtioPciSetupIRQ: failed to get supported interrupt types\n"));
+    return rc;
+}
+
+
+/**
+ * Removes IRQ for Virtio PCI device.
+ *
+ * @param   pDip     Pointer to the device info structure.
+ */
+static void VirtioPciRemoveIRQ(dev_info_t *pDip)
+{
+    LogFlow((VIRTIOLOGNAME ":VirtioPciRemoveIRQ pDip=%p:\n", pDip));
+
+    for (int i = 0; i < g_cIntrAllocated; i++)
+    {
+        int rc = ddi_intr_disable(g_pIntr[i]);
+        if (rc == DDI_SUCCESS)
+        {
+            rc = ddi_intr_remove_handler(g_pIntr[i]);
+            if (rc == DDI_SUCCESS)
+                ddi_intr_free(g_pIntr[i]);
+        }
+    }
+    RTMemFree(g_pIntr);
+    mutex_destroy(&g_IrqMtx);
+}
+
+
+/**
+ * Interrupt Service Routine for Virtio PCI device.
+ *
+ * @param   Arg     Private data (unused, will be NULL).
+ * @returns DDI_INTR_CLAIMED if it's our interrupt, DDI_INTR_UNCLAIMED if it isn't.
+ */
+static uint_t VirtioPciISR(caddr_t Arg)
+{
+    LogFlow((VIRTIOLOGNAME ":VBoxGuestSolarisISR\n"));
+    cmn_err(CE_NOTE, "VBoxGuestSolarisISRd Arg=%p\n", Arg);
+
+    mutex_enter(&g_IrqMtx);
+    bool fOurIRQ = false;
+    /*
+     * Call the DeviceOps ISR routine somehow which should notify all Virtio queues
+     * on the interrupt.
+     */
+    mutex_exit(&g_IrqMtx);
+
+    return fOurIRQ ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED;
+}
+
diff --git a/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.h b/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.h
new file mode 100644
index 00000000..990fe544
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/VirtioPci-solaris.h
@@ -0,0 +1,38 @@
+/* $Id: VirtioPci-solaris.h $ */
+/** @file
+ * VirtualBox Guest Additions: Virtio Driver for Solaris, PCI Hypervisor Interface.
+ */
+
+/*
+ * Copyright (C) 2010-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+#ifndef GA_INCLUDED_SRC_solaris_Virtio_VirtioPci_solaris_h
+#define GA_INCLUDED_SRC_solaris_Virtio_VirtioPci_solaris_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "Virtio-solaris.h"
+
+extern VIRTIOHYPEROPS g_VirtioHyperOpsPci;
+
+#endif /* !GA_INCLUDED_SRC_solaris_Virtio_VirtioPci_solaris_h */
+
diff --git a/src/VBox/Additions/solaris/Virtio/VirtioRing-solaris.c b/src/VBox/Additions/solaris/Virtio/VirtioRing-solaris.c
new file mode 100644
index 00000000..552163ac
--- /dev/null
+++ b/src/VBox/Additions/solaris/Virtio/VirtioRing-solaris.c
@@ -0,0 +1,138 @@
+/* $Id: VirtioRing-solaris.c $ */
+/** @file
+ * VirtualBox Guest Additions: Virtio Driver for Solaris, Ring implementation.
+ */
+
+/*
+ * Copyright (C) 2010-2020 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "Virtio-solaris.h"
+
+#include <iprt/asm.h>
+#include <iprt/cdefs.h>
+#include <iprt/assert.h>
+#include <iprt/errcore.h>
+#include <iprt/log.h>
+
+#include <sys/cmn_err.h>
+
+/**
+ * Returns the size of the ring in bytes given the number of elements and
+ * alignment requirements.
+ *
+ * @param cElements         Number of elements.
+ * @param Align             Alignment (must be a power of two).
+ *
+ * @return Size of the Virtio ring.
+ */
+size_t VirtioRingSize(uint64_t cElements, ulong_t Align)
+{
+    size_t cb = 0;
+    cb  = cElements * sizeof(VIRTIORINGDESC);   /* Ring descriptors. */
+    cb += 2 * sizeof(uint16_t);                 /* Available flags and index. */
+    cb += cElements * sizeof(uint16_t);         /* Available descriptors. */
+
+    size_t cbAlign = RT_ALIGN_Z(cb, Align);
+    cbAlign += 2 * sizeof(uint16_t);                    /* Used flags and index. */
+    cbAlign += cElements * sizeof(VIRTIORINGUSEDELEM);  /* Used descriptors. */
+
+    return cbAlign;
+}
+
+
+/**
+ * Initializes a ring of a queue. This associates the DMA virtual address
+ * with the Ring structure's "pRingDesc".
+ *
+ * @param pQueue            Pointer to the Virtio Queue.
+ * @param cDescs            Number of descriptors.
+ * @param virtBuf           Buffer associated with the ring.
+ * @param Align             Alignment (must be power of two).
+ */
+void VirtioRingInit(PVIRTIOQUEUE pQueue, uint_t cDescs, caddr_t virtBuf, ulong_t Align)
+{
+    PVIRTIORING pRing = &pQueue->Ring;
+    pRing->cDesc          = cDescs;
+    pRing->pRingDesc      = (void *)virtBuf;
+    pRing->pRingAvail     = (PVIRTIORINGAVAIL)(virtBuf + (cDescs * sizeof(pRing->pRingDesc[0])));
+    pRing->pRingUsedElem  = RT_ALIGN_PT(pRing->pRingAvail + RT_UOFFSETOF_DYN(VIRTIORINGAVAIL, aRings[pQueue->Ring.cDesc]), Align,
+                                        PVIRTIORINGUSEDELEM);
+
+    for (uint_t i = 0; i < pRing->cDesc - 1; i++)
+        pRing->pRingDesc[i].Next = i + 1;
+
+    pQueue->FreeHeadIndex = 0;
+
+    cmn_err(CE_NOTE, "cDesc=%u pRingDesc=%p pRingAvail=%p\n", pRing->cDesc, pRing->pRingDesc, pRing->pRingAvail);
+}
+
+
+/**
+ * Push a buffer into the ring.
+ *
+ * @param pQueue            Pointer to the Virtio queue.
+ * @param physBuf           Physical address of the buffer.
+ * @param cbBuf             Size of the buffer in bytes.
+ * @param fFlags            Buffer flags, see VIRTIO_FLAGS_RING_DESC_*.
+ *
+ * @return IPRT error code.
+ */
+int VirtioRingPush(PVIRTIOQUEUE pQueue, paddr_t physBuf, uint32_t cbBuf, uint16_t fFlags)
+{
+    /*
+     * Claim a slot, fill the buffer and move head pointer.
+     */
+    uint_t FreeIndex          = pQueue->FreeHeadIndex;
+    PVIRTIORING pRing         = &pQueue->Ring;
+
+    if (FreeIndex >= pRing->cDesc - 1)
+    {
+        LogRel((VIRTIOLOGNAME ":VirtioRingPush: failed. No free descriptors. cDesc=%u\n", pRing->cDesc));
+        return VERR_BUFFER_OVERFLOW;
+    }
+
+    PVIRTIORINGDESC pRingDesc = &pRing->pRingDesc[FreeIndex];
+
+    AssertCompile(sizeof(physBuf) == sizeof(pRingDesc->AddrBuf));
+
+    pQueue->cBufs++;
+    uint_t AvailIndex = (pRing->pRingAvail->Index + pQueue->cBufs) % pQueue->Ring.cDesc;
+    pRing->pRingAvail->aRings[AvailIndex - 1] = FreeIndex;
+
+    pRingDesc->AddrBuf = physBuf;
+    pRingDesc->cbBuf   = cbBuf;
+    pRingDesc->fFlags  = fFlags;
+
+    pQueue->FreeHeadIndex = pRingDesc->Next;
+
+    ASMCompilerBarrier();
+
+    cmn_err(CE_NOTE, "VirtioRingPush: cbBuf=%u FreeIndex=%u AvailIndex=%u cDesc=%u Queue->cBufs=%u\n",
+            cbBuf, FreeIndex, AvailIndex, pQueue->Ring.cDesc,
+            pQueue->cBufs);
+
+    return VINF_SUCCESS;
+}
+