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

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

1 files changed, 842 insertions, 0 deletions

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..d116cb24
--- /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-2019 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;
+}
+