diff options
Diffstat (limited to 'src/VBox/Main/src-server/solaris')
| -rw-r--r-- | src/VBox/Main/src-server/solaris/DynLoadLibSolaris.cpp | 85 | ||||
| -rw-r--r-- | src/VBox/Main/src-server/solaris/DynLoadLibSolaris.h | 50 | ||||
| -rw-r--r-- | src/VBox/Main/src-server/solaris/Makefile.kup | 0 | ||||
| -rw-r--r-- | src/VBox/Main/src-server/solaris/NetIf-solaris.cpp | 559 | ||||
| -rw-r--r-- | src/VBox/Main/src-server/solaris/PerformanceSolaris.cpp | 744 | ||||
| -rw-r--r-- | src/VBox/Main/src-server/solaris/USBProxyBackendSolaris.cpp | 496 |
6 files changed, 1934 insertions, 0 deletions
diff --git a/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.cpp b/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.cpp new file mode 100644 index 00000000..b8236e01 --- /dev/null +++ b/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.cpp @@ -0,0 +1,85 @@ +/* $Id: DynLoadLibSolaris.cpp $ */ +/** @file + * Dynamically load libraries for Solaris hosts. + */ + +/* + * Copyright (C) 2008-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include "DynLoadLibSolaris.h" + +#include <iprt/errcore.h> +#include <iprt/ldr.h> + + +/** -=-=-=-=-= LIB DLPI -=-=-=-=-=-=- **/ + +/** + * Global pointer to the libdlpi module. This should only be set once all needed libraries + * and symbols have been successfully loaded. + */ +static RTLDRMOD g_hLibDlpi = NIL_RTLDRMOD; + +/** + * Whether we have tried to load libdlpi yet. This flag should only be set + * to "true" after we have either loaded both libraries and all symbols which we need, + * or failed to load something and unloaded. + */ +static bool g_fCheckedForLibDlpi = false; + +/** All the symbols we need from libdlpi. + * @{ + */ +int (*g_pfnLibDlpiWalk)(dlpi_walkfunc_t *, void *, uint_t); +int (*g_pfnLibDlpiOpen)(const char *, dlpi_handle_t *, uint_t); +void (*g_pfnLibDlpiClose)(dlpi_handle_t); +/** @} */ + +bool VBoxSolarisLibDlpiFound(void) +{ + RTLDRMOD hLibDlpi; + + if (g_fCheckedForLibDlpi) + return g_hLibDlpi != NIL_RTLDRMOD; + g_fCheckedForLibDlpi = true; + int vrc = RTLdrLoad(LIB_DLPI, &hLibDlpi); + if (RT_SUCCESS(vrc)) + { + /* + * Unfortunately; we cannot make use of dlpi_get_physaddr because it requires us to + * open the VNIC/link which requires root permissions :/ + */ + vrc = RTLdrGetSymbol(hLibDlpi, "dlpi_walk", (void **)&g_pfnLibDlpiWalk); + vrc |= RTLdrGetSymbol(hLibDlpi, "dlpi_close", (void **)&g_pfnLibDlpiClose); + vrc |= RTLdrGetSymbol(hLibDlpi, "dlpi_open", (void **)&g_pfnLibDlpiOpen); + if (RT_SUCCESS(vrc)) + { + g_hLibDlpi = hLibDlpi; + return true; + } + + RTLdrClose(hLibDlpi); + } + hLibDlpi = NIL_RTLDRMOD; + return false; +} + diff --git a/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.h b/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.h new file mode 100644 index 00000000..56c85108 --- /dev/null +++ b/src/VBox/Main/src-server/solaris/DynLoadLibSolaris.h @@ -0,0 +1,50 @@ +/* $Id: DynLoadLibSolaris.h $ */ +/** @file + * Dynamically loaded libraries for Solaris hosts, Internal header. + */ + +/* + * Copyright (C) 2008-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#ifndef MAIN_INCLUDED_SRC_src_server_solaris_DynLoadLibSolaris_h +#define MAIN_INCLUDED_SRC_src_server_solaris_DynLoadLibSolaris_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#define LIB_DLPI "libdlpi.so.1" +#ifdef RT_OS_SOLARIS_10 +#include <sys/dlpi.h> +#else +#include <libdlpi.h> +#endif + +typedef boolean_t dlpi_walkfunc_t(const char*, void *); + +extern int (*g_pfnLibDlpiWalk)(dlpi_walkfunc_t *, void *, uint_t); +extern int (*g_pfnLibDlpiOpen)(const char *, dlpi_handle_t *, uint_t); +extern void (*g_pfnLibDlpiClose)(dlpi_handle_t); + +extern bool VBoxSolarisLibDlpiFound(void); + +#endif /* !MAIN_INCLUDED_SRC_src_server_solaris_DynLoadLibSolaris_h */ + diff --git a/src/VBox/Main/src-server/solaris/Makefile.kup b/src/VBox/Main/src-server/solaris/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/Main/src-server/solaris/Makefile.kup diff --git a/src/VBox/Main/src-server/solaris/NetIf-solaris.cpp b/src/VBox/Main/src-server/solaris/NetIf-solaris.cpp new file mode 100644 index 00000000..8958f822 --- /dev/null +++ b/src/VBox/Main/src-server/solaris/NetIf-solaris.cpp @@ -0,0 +1,559 @@ +/* $Id: NetIf-solaris.cpp $ */ +/** @file + * Main - NetIfList, Solaris implementation. + */ + +/* + * Copyright (C) 2008-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_MAIN_HOST + +#include <iprt/errcore.h> +#include <iprt/ctype.h> +#include <iprt/mem.h> +#include <iprt/path.h> +#include <list> + +#include "LoggingNew.h" +#include "HostNetworkInterfaceImpl.h" +#include "netif.h" + +#ifdef VBOX_WITH_HOSTNETIF_API + +#include <map> +#include <iprt/sanitized/string> +#include <fcntl.h> +#include <unistd.h> +#include <stropts.h> +#include <limits.h> +#include <stdio.h> +#include <libdevinfo.h> +#include <net/if.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if_arp.h> +#include <net/if.h> +#include <sys/types.h> +#include <kstat.h> + +#include "DynLoadLibSolaris.h" + +/** @todo Unify this define with VBoxNetFltBow-solaris.c */ +#define VBOXBOW_VNIC_TEMPLATE_NAME "vboxvnic_template" + + +static uint32_t getInstance(const char *pszIfaceName, char *pszDevName) +{ + /* + * Get the instance number from the interface name, then clip it off. + */ + int cbInstance = 0; + size_t cbIface = strlen(pszIfaceName); + const char *pszEnd = pszIfaceName + cbIface - 1; + for (size_t i = 0; i < cbIface - 1; i++) + { + if (!RT_C_IS_DIGIT(*pszEnd)) + break; + cbInstance++; + pszEnd--; + } + + uint32_t uInstance = RTStrToUInt32(pszEnd + 1); + strncpy(pszDevName, pszIfaceName, cbIface - cbInstance); + pszDevName[cbIface - cbInstance] = '\0'; + return uInstance; +} + +static uint32_t kstatGet(const char *name) +{ + kstat_ctl_t *kc; + uint32_t uSpeed = 0; + + if ((kc = kstat_open()) == 0) + { + LogRel(("kstat_open() -> %d\n", errno)); + return 0; + } + + kstat_t *ksAdapter = kstat_lookup(kc, (char *)"link", -1, (char *)name); + if (ksAdapter == 0) + { + char szModule[KSTAT_STRLEN]; + uint32_t uInstance = getInstance(name, szModule); + ksAdapter = kstat_lookup(kc, szModule, uInstance, (char *)"phys"); + if (ksAdapter == 0) + ksAdapter = kstat_lookup(kc, szModule, uInstance, (char*)name); + } + if (ksAdapter == 0) + LogRel(("Failed to get network statistics for %s\n", name)); + else if (kstat_read(kc, ksAdapter, 0) == -1) + LogRel(("kstat_read(%s) -> %d\n", name, errno)); + else + { + kstat_named_t *kn; + if ((kn = (kstat_named_t *)kstat_data_lookup(ksAdapter, (char *)"ifspeed")) != NULL) + uSpeed = (uint32_t)(kn->value.ul / 1000000); /* bits -> Mbits */ + else + LogRel(("kstat_data_lookup(ifspeed) -> %d, name=%s\n", errno, name)); + } + kstat_close(kc); + LogFlow(("kstatGet(%s) -> %u Mbit/s\n", name, uSpeed)); + return uSpeed; +} + +static void queryIfaceSpeed(PNETIFINFO pInfo) +{ + /* Don't query interface speed for inactive interfaces (see @bugref{6345}). */ + if (pInfo->enmStatus == NETIF_S_UP) + pInfo->uSpeedMbits = kstatGet(pInfo->szShortName); + else + pInfo->uSpeedMbits = 0; + LogFlow(("queryIfaceSpeed(%s) -> %u\n", pInfo->szShortName, pInfo->uSpeedMbits)); +} + +static void vboxSolarisAddHostIface(char *pszIface, int Instance, void *pvHostNetworkInterfaceList) +{ + std::list<ComObjPtr<HostNetworkInterface> > *pList = + (std::list<ComObjPtr<HostNetworkInterface> > *)pvHostNetworkInterfaceList; + Assert(pList); + + typedef std::map <std::string, std::string> NICMap; + typedef std::pair <std::string, std::string> NICPair; + static NICMap SolarisNICMap; + if (SolarisNICMap.empty()) + { + SolarisNICMap.insert(NICPair("afe", "ADMtek Centaur/Comet Fast Ethernet")); + SolarisNICMap.insert(NICPair("atge", "Atheros/Attansic Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("aggr", "Link Aggregation Interface")); + SolarisNICMap.insert(NICPair("bfe", "Broadcom BCM4401 Fast Ethernet")); + SolarisNICMap.insert(NICPair("bge", "Broadcom BCM57xx Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("bnx", "Broadcom NetXtreme Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("bnxe", "Broadcom NetXtreme II 10 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("ce", "Cassini Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("chxge", "Chelsio Ethernet")); + SolarisNICMap.insert(NICPair("dmfe", "Davicom 9102 Fast Ethernet")); + SolarisNICMap.insert(NICPair("dnet", "DEC 21040/41 21140 Ethernet")); + SolarisNICMap.insert(NICPair("e1000", "Intel PRO/1000 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("e1000g", "Intel PRO/1000 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("elx", "3COM Etherlink III Ethernet")); + SolarisNICMap.insert(NICPair("elxl", "3COM Etherlink XL Ethernet")); + SolarisNICMap.insert(NICPair("eri", "eri Fast Ethernet")); + SolarisNICMap.insert(NICPair("ge", "GEM Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("hme", "SUNW,hme Fast-Ethernet")); + SolarisNICMap.insert(NICPair("hxge", "Sun Blade 10 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("igb", "Intel 82575 PCI-E Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("ipge", "PCI-E Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("iprb", "Intel 82557/58/59 Ethernet")); + SolarisNICMap.insert(NICPair("ixgb", "Intel 82597ex 10 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("ixgbe", "Intel 10 Gigabit PCI-E Ethernet")); + SolarisNICMap.insert(NICPair("mcxe", "Mellanox ConnectX-2 10 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("mxfe", "Macronix 98715 Fast Ethernet")); + SolarisNICMap.insert(NICPair("nfo", "Nvidia Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("nge", "Nvidia Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("ntxn", "NetXen 10/1 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("nxge", "Sun 10/1 Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("pcelx", "3COM EtherLink III PCMCIA Ethernet")); + SolarisNICMap.insert(NICPair("pcn", "AMD PCnet Ethernet")); + SolarisNICMap.insert(NICPair("qfe", "SUNW,qfe Quad Fast-Ethernet")); + SolarisNICMap.insert(NICPair("rge", "Realtek Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("rtls", "Realtek 8139 Fast Ethernet")); + SolarisNICMap.insert(NICPair("sfe", "SiS900 Fast Ethernet")); + SolarisNICMap.insert(NICPair("skge", "SksKonnect Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("spwr", "SMC EtherPower II 10/100 (9432) Ethernet")); + SolarisNICMap.insert(NICPair("vboxnet", "VirtualBox Host Ethernet")); + SolarisNICMap.insert(NICPair(VBOXBOW_VNIC_TEMPLATE_NAME, "VirtualBox VNIC Template")); + SolarisNICMap.insert(NICPair("vlan", "Virtual LAN Ethernet")); + SolarisNICMap.insert(NICPair("vr", "VIA Rhine Fast Ethernet")); + SolarisNICMap.insert(NICPair("vnic", "Virtual Network Interface Ethernet")); + SolarisNICMap.insert(NICPair("xge", "Neterior Xframe 10Gigabit Ethernet")); + SolarisNICMap.insert(NICPair("yge", "Marvell Yukon 2 Fast Ethernet")); + } + + /* + * Try picking up description from our NIC map. + */ + char szNICInstance[128]; + RTStrPrintf(szNICInstance, sizeof(szNICInstance), "%s%d", pszIface, Instance); + char szNICDesc[256]; + std::string Description = SolarisNICMap[pszIface]; + if (Description != "VirtualBox Host Ethernet") + { + if (Description != "") + RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - %s", szNICInstance, Description.c_str()); + else if (!strncmp(szNICInstance, RT_STR_TUPLE(VBOXBOW_VNIC_TEMPLATE_NAME))) + { + /* + * We want prefix matching only for "vboxvnic_template" as it's possible to create "vboxvnic_template_abcd123", + * which our Solaris Crossbow NetFilter driver will interpret as a VNIC template. + */ + Description = SolarisNICMap[VBOXBOW_VNIC_TEMPLATE_NAME]; + RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - %s", szNICInstance, Description.c_str()); + } + else + RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - Ethernet", szNICInstance); + } + else + RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s", szNICInstance); + + /* + * Try to get IP V4 address and netmask as well as Ethernet address. + */ + NETIFINFO Info; + RT_ZERO(Info); + int Sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); + if (Sock > 0) + { + struct lifreq IfReq; + RTStrCopy(IfReq.lifr_name, sizeof(IfReq.lifr_name), szNICInstance); + if (ioctl(Sock, SIOCGLIFADDR, &IfReq) >= 0) + { + memcpy(Info.IPAddress.au8, &((struct sockaddr_in *)&IfReq.lifr_addr)->sin_addr.s_addr, + sizeof(Info.IPAddress.au8)); + struct arpreq ArpReq; + memcpy(&ArpReq.arp_pa, &IfReq.lifr_addr, sizeof(struct sockaddr_in)); + + /* + * We might fail if the interface has not been assigned an IP address. + * That doesn't matter; as long as it's plumbed we can pick it up. + * But, if it has not acquired an IP address we cannot obtain it's MAC + * address this way, so we just use all zeros there. + */ + if (ioctl(Sock, SIOCGARP, &ArpReq) >= 0) + { + memcpy(&Info.MACAddress, ArpReq.arp_ha.sa_data, sizeof(Info.MACAddress)); + } + + } + + if (ioctl(Sock, SIOCGLIFNETMASK, &IfReq) >= 0) + { + memcpy(Info.IPNetMask.au8, &((struct sockaddr_in *)&IfReq.lifr_addr)->sin_addr.s_addr, + sizeof(Info.IPNetMask.au8)); + } + if (ioctl(Sock, SIOCGLIFFLAGS, &IfReq) >= 0) + { + Info.enmStatus = IfReq.lifr_flags & IFF_UP ? NETIF_S_UP : NETIF_S_DOWN; + } + close(Sock); + } + /* + * Try to get IP V6 address and netmask. + */ + Sock = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP); + if (Sock > 0) + { + struct lifreq IfReq; + RTStrCopy(IfReq.lifr_name, sizeof(IfReq.lifr_name), szNICInstance); + if (ioctl(Sock, SIOCGLIFADDR, &IfReq) >= 0) + { + memcpy(Info.IPv6Address.au8, ((struct sockaddr_in6 *)&IfReq.lifr_addr)->sin6_addr.s6_addr, + sizeof(Info.IPv6Address.au8)); + } + if (ioctl(Sock, SIOCGLIFNETMASK, &IfReq) >= 0) + { + memcpy(Info.IPv6NetMask.au8, ((struct sockaddr_in6 *)&IfReq.lifr_addr)->sin6_addr.s6_addr, + sizeof(Info.IPv6NetMask.au8)); + } + close(Sock); + } + + /* + * Construct UUID with interface name and the MAC address if available. + */ + RTUUID Uuid; + RTUuidClear(&Uuid); + memcpy(&Uuid, szNICInstance, RT_MIN(strlen(szNICInstance), sizeof(Uuid))); + Uuid.Gen.u8ClockSeqHiAndReserved = (Uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80; + Uuid.Gen.u16TimeHiAndVersion = (Uuid.Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000; + Uuid.Gen.au8Node[0] = Info.MACAddress.au8[0]; + Uuid.Gen.au8Node[1] = Info.MACAddress.au8[1]; + Uuid.Gen.au8Node[2] = Info.MACAddress.au8[2]; + Uuid.Gen.au8Node[3] = Info.MACAddress.au8[3]; + Uuid.Gen.au8Node[4] = Info.MACAddress.au8[4]; + Uuid.Gen.au8Node[5] = Info.MACAddress.au8[5]; + Info.Uuid = Uuid; + Info.enmMediumType = NETIF_T_ETHERNET; + strncpy(Info.szShortName, szNICInstance, sizeof(Info.szShortName) - 1); + + HostNetworkInterfaceType_T enmType; + if (strncmp(szNICInstance, RT_STR_TUPLE("vboxnet"))) + enmType = HostNetworkInterfaceType_Bridged; + else + enmType = HostNetworkInterfaceType_HostOnly; + queryIfaceSpeed(&Info); + ComObjPtr<HostNetworkInterface> IfObj; + IfObj.createObject(); + if (SUCCEEDED(IfObj->init(szNICDesc, enmType, &Info))) + pList->push_back(IfObj); +} + +static boolean_t vboxSolarisAddLinkHostIface(const char *pszIface, void *pvHostNetworkInterfaceList) +{ + /* + * Skip IPSEC interfaces. It's at IP level. + */ + if (!strncmp(pszIface, RT_STR_TUPLE("ip.tun"))) + return _B_FALSE; + + /* + * Skip our own dynamic VNICs but don't skip VNIC templates. + * These names originate from VBoxNetFltBow-solaris.c, hardcoded here for now. + * . + * ASSUMES template name is longer than 'vboxvnic'. + */ + if ( strncmp(pszIface, RT_STR_TUPLE(VBOXBOW_VNIC_TEMPLATE_NAME)) + && !strncmp(pszIface, RT_STR_TUPLE("vboxvnic"))) + return _B_FALSE; + + /* + * Clip off the zone instance number from the interface name (if any). + */ + char szIfaceName[128]; + strcpy(szIfaceName, pszIface); + char *pszColon = (char *)memchr(szIfaceName, ':', sizeof(szIfaceName)); + if (pszColon) + *pszColon = '\0'; + + /* + * Get the instance number from the interface name, then clip it off. + */ + int cbInstance = 0; + size_t cbIface = strlen(szIfaceName); + const char *pszEnd = pszIface + cbIface - 1; + for (size_t i = 0; i < cbIface - 1; i++) + { + if (!RT_C_IS_DIGIT(*pszEnd)) + break; + cbInstance++; + pszEnd--; + } + + int Instance = atoi(pszEnd + 1); + strncpy(szIfaceName, pszIface, cbIface - cbInstance); + szIfaceName[cbIface - cbInstance] = '\0'; + + /* + * Add the interface. + */ + vboxSolarisAddHostIface(szIfaceName, Instance, pvHostNetworkInterfaceList); + + /* + * Continue walking... + */ + return _B_FALSE; +} + +static bool vboxSolarisSortNICList(const ComObjPtr<HostNetworkInterface> Iface1, const ComObjPtr<HostNetworkInterface> Iface2) +{ + Bstr Iface1Str; + (*Iface1).COMGETTER(Name) (Iface1Str.asOutParam()); + + Bstr Iface2Str; + (*Iface2).COMGETTER(Name) (Iface2Str.asOutParam()); + + return Iface1Str < Iface2Str; +} + +static bool vboxSolarisSameNIC(const ComObjPtr<HostNetworkInterface> Iface1, const ComObjPtr<HostNetworkInterface> Iface2) +{ + Bstr Iface1Str; + (*Iface1).COMGETTER(Name) (Iface1Str.asOutParam()); + + Bstr Iface2Str; + (*Iface2).COMGETTER(Name) (Iface2Str.asOutParam()); + + return (Iface1Str == Iface2Str); +} + +static int vboxSolarisAddPhysHostIface(di_node_t Node, di_minor_t Minor, void *pvHostNetworkInterfaceList) +{ + NOREF(Minor); + + char *pszDriverName = di_driver_name(Node); + int Instance = di_instance(Node); + + /* + * Skip aggregations. + */ + if (!strcmp(pszDriverName, "aggr")) + return DI_WALK_CONTINUE; + + /* + * Skip softmacs. + */ + if (!strcmp(pszDriverName, "softmac")) + return DI_WALK_CONTINUE; + + /* + * Driver names doesn't always imply the same link name probably since + * S11's vanity names by default (e.g. highly descriptive "net0") names + * was introduced. Try opening the link to find out if it really exists. + * + * This weeds out listing of "e1000g0" as a valid interface on my S11.2 + * Dell Optiplex box. + */ + if (VBoxSolarisLibDlpiFound()) + { + /** @todo should we try also opening "linkname+instance"? */ + dlpi_handle_t hLink; + if (g_pfnLibDlpiOpen(pszDriverName, &hLink, 0) != DLPI_SUCCESS) + return DI_WALK_CONTINUE; + g_pfnLibDlpiClose(hLink); + } + + vboxSolarisAddHostIface(pszDriverName, Instance, pvHostNetworkInterfaceList); + return DI_WALK_CONTINUE; +} + +int NetIfList(std::list<ComObjPtr<HostNetworkInterface> > &list) +{ + /* + * Use libdevinfo for determining all physical interfaces. + */ + di_node_t Root; + Root = di_init("/", DINFOCACHE); + if (Root != DI_NODE_NIL) + { + di_walk_minor(Root, DDI_NT_NET, 0 /* flag */, &list, vboxSolarisAddPhysHostIface); + di_fini(Root); + } + + /* + * Use libdlpi for determining all DLPI interfaces. + */ + if (VBoxSolarisLibDlpiFound()) + g_pfnLibDlpiWalk(vboxSolarisAddLinkHostIface, &list, 0); + + /* + * This gets only the list of all plumbed logical interfaces. + * This is needed for zones which cannot access the device tree + * and in this case we just let them use the list of plumbed interfaces + * on the zone. + */ + int Sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); + if (Sock > 0) + { + struct lifnum IfNum; + RT_ZERO(IfNum); + IfNum.lifn_family = AF_INET; + int iRc = ioctl(Sock, SIOCGLIFNUM, &IfNum); + if (!iRc) + { + int cIfaces = RT_MIN(1024, IfNum.lifn_count); /* sane limit */ + size_t cbIfaces = (unsigned)RT_MAX(cIfaces, 1) * sizeof(struct lifreq); + struct lifreq *paIfaces = (struct lifreq *)RTMemTmpAlloc(cbIfaces); + if (paIfaces) + { + struct lifconf IfConfig; + RT_ZERO(IfConfig); + IfConfig.lifc_family = AF_INET; + IfConfig.lifc_len = (int)cbIfaces; + IfConfig.lifc_buf = (caddr_t)paIfaces; + iRc = ioctl(Sock, SIOCGLIFCONF, &IfConfig); + if (!iRc) + { + for (int i = 0; i < cIfaces; i++) + { + /* + * Skip loopback interfaces. + */ + if (!strncmp(paIfaces[i].lifr_name, RT_STR_TUPLE("lo"))) + continue; + +#if 0 + iRc = ioctl(Sock, SIOCGLIFADDR, &(paIfaces[i])); + if (iRc >= 0) + { + memcpy(Info.IPAddress.au8, ((struct sockaddr *)&paIfaces[i].lifr_addr)->sa_data, + sizeof(Info.IPAddress.au8)); + // SIOCGLIFNETMASK + struct arpreq ArpReq; + memcpy(&ArpReq.arp_pa, &paIfaces[i].lifr_addr, sizeof(struct sockaddr_in)); + + /* + * We might fail if the interface has not been assigned an IP address. + * That doesn't matter; as long as it's plumbed we can pick it up. + * But, if it has not acquired an IP address we cannot obtain it's MAC + * address this way, so we just use all zeros there. + */ + iRc = ioctl(Sock, SIOCGARP, &ArpReq); + if (iRc >= 0) + memcpy(&Info.MACAddress, ArpReq.arp_ha.sa_data, sizeof(Info.MACAddress)); + + char szNICDesc[LIFNAMSIZ + 256]; + char *pszIface = paIfaces[i].lifr_name; + strcpy(szNICDesc, pszIface); + + vboxSolarisAddLinkHostIface(pszIface, &list); + } +#endif + + vboxSolarisAddLinkHostIface(paIfaces[i].lifr_name, &list); + } + } + RTMemTmpFree(paIfaces); + } + } + close(Sock); + } + + /* + * Weed out duplicates caused by dlpi_walk inconsistencies across Nevadas. + */ + list.sort(vboxSolarisSortNICList); + list.unique(vboxSolarisSameNIC); + + return VINF_SUCCESS; +} + +#else +int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list) +{ + return VERR_NOT_IMPLEMENTED; +} +#endif + +int NetIfGetConfigByName(PNETIFINFO pInfo) +{ + NOREF(pInfo); + return VERR_NOT_IMPLEMENTED; +} + +/** + * Retrieve the physical link speed in megabits per second. If the interface is + * not up or otherwise unavailable the zero speed is returned. + * + * @returns VBox status code. + * + * @param pcszIfName Interface name. + * @param puMbits Where to store the link speed. + */ +int NetIfGetLinkSpeed(const char *pcszIfName, uint32_t *puMbits) +{ + *puMbits = kstatGet(pcszIfName); + return VINF_SUCCESS; +} diff --git a/src/VBox/Main/src-server/solaris/PerformanceSolaris.cpp b/src/VBox/Main/src-server/solaris/PerformanceSolaris.cpp new file mode 100644 index 00000000..169c51ca --- /dev/null +++ b/src/VBox/Main/src-server/solaris/PerformanceSolaris.cpp @@ -0,0 +1,744 @@ +/* $Id: PerformanceSolaris.cpp $ */ +/** @file + * VBox Solaris-specific Performance Classes implementation. + */ + +/* + * Copyright (C) 2008-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#define LOG_GROUP LOG_GROUP_MAIN_PERFORMANCECOLLECTOR +#undef _FILE_OFFSET_BITS +#include <procfs.h> +#include <stdio.h> +#include <errno.h> +#include <fcntl.h> +#include <kstat.h> +#include <unistd.h> +#include <sys/sysinfo.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/statvfs.h> + +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/string.h> +#include <iprt/alloc.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/system.h> + +#include "LoggingNew.h" +#include "Performance.h" + +#include <dlfcn.h> + +#include <libzfs.h> +#include <libnvpair.h> + +#include <map> + +namespace pm { + + typedef libzfs_handle_t *(*PFNZFSINIT)(void); + typedef void (*PFNZFSFINI)(libzfs_handle_t *); + typedef zfs_handle_t *(*PFNZFSOPEN)(libzfs_handle_t *, const char *, int); + typedef void (*PFNZFSCLOSE)(zfs_handle_t *); + typedef uint64_t (*PFNZFSPROPGETINT)(zfs_handle_t *, zfs_prop_t); + typedef zpool_handle_t *(*PFNZPOOLOPEN)(libzfs_handle_t *, const char *); + typedef void (*PFNZPOOLCLOSE)(zpool_handle_t *); + typedef nvlist_t *(*PFNZPOOLGETCONFIG)(zpool_handle_t *, nvlist_t **); + typedef char *(*PFNZPOOLVDEVNAME)(libzfs_handle_t *, zpool_handle_t *, nvlist_t *, boolean_t); + + typedef std::map<RTCString,RTCString> FsMap; + +class CollectorSolaris : public CollectorHAL +{ +public: + CollectorSolaris(); + virtual ~CollectorSolaris(); + virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available); + virtual int getHostFilesystemUsage(const char *name, ULONG *total, ULONG *used, ULONG *available); + virtual int getHostDiskSize(const char *name, uint64_t *size); + virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used); + + virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle); + virtual int getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx); + virtual int getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms); + virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total); + + virtual int getDiskListByFs(const char *name, DiskList& listUsage, DiskList& listLoad); +private: + static uint32_t getInstance(const char *pszIfaceName, char *pszDevName); + uint64_t getZfsTotal(uint64_t cbTotal, const char *szFsType, const char *szFsName); + void updateFilesystemMap(void); + RTCString physToInstName(const char *pcszPhysName); + RTCString pathToInstName(const char *pcszDevPathName); + uint64_t wrapCorrection(uint32_t cur, uint64_t prev, const char *name); + uint64_t wrapDetection(uint64_t cur, uint64_t prev, const char *name); + + kstat_ctl_t *mKC; + kstat_t *mSysPages; + kstat_t *mZFSCache; + + void *mZfsSo; + libzfs_handle_t *mZfsLib; + PFNZFSINIT mZfsInit; + PFNZFSFINI mZfsFini; + PFNZFSOPEN mZfsOpen; + PFNZFSCLOSE mZfsClose; + PFNZFSPROPGETINT mZfsPropGetInt; + PFNZPOOLOPEN mZpoolOpen; + PFNZPOOLCLOSE mZpoolClose; + PFNZPOOLGETCONFIG mZpoolGetConfig; + PFNZPOOLVDEVNAME mZpoolVdevName; + + FsMap mFsMap; + uint32_t mCpus; + ULONG totalRAM; +}; + +CollectorHAL *createHAL() +{ + return new CollectorSolaris(); +} + +// Collector HAL for Solaris + + +CollectorSolaris::CollectorSolaris() + : mKC(0), + mSysPages(0), + mZFSCache(0), + mZfsLib(0), + mCpus(0) +{ + if ((mKC = kstat_open()) == 0) + { + Log(("kstat_open() -> %d\n", errno)); + return; + } + + if ((mSysPages = kstat_lookup(mKC, (char *)"unix", 0, (char *)"system_pages")) == 0) + { + Log(("kstat_lookup(system_pages) -> %d\n", errno)); + return; + } + + if ((mZFSCache = kstat_lookup(mKC, (char *)"zfs", 0, (char *)"arcstats")) == 0) + { + Log(("kstat_lookup(system_pages) -> %d\n", errno)); + } + + /* Try to load libzfs dynamically, it may be missing. */ + mZfsSo = dlopen("libzfs.so", RTLD_LAZY); + if (mZfsSo) + { + mZfsInit = (PFNZFSINIT)(uintptr_t)dlsym(mZfsSo, "libzfs_init"); + mZfsFini = (PFNZFSFINI)(uintptr_t)dlsym(mZfsSo, "libzfs_fini"); + mZfsOpen = (PFNZFSOPEN)(uintptr_t)dlsym(mZfsSo, "zfs_open"); + mZfsClose = (PFNZFSCLOSE)(uintptr_t)dlsym(mZfsSo, "zfs_close"); + mZfsPropGetInt = (PFNZFSPROPGETINT)(uintptr_t)dlsym(mZfsSo, "zfs_prop_get_int"); + mZpoolOpen = (PFNZPOOLOPEN)(uintptr_t)dlsym(mZfsSo, "zpool_open"); + mZpoolClose = (PFNZPOOLCLOSE)(uintptr_t)dlsym(mZfsSo, "zpool_close"); + mZpoolGetConfig = (PFNZPOOLGETCONFIG)(uintptr_t)dlsym(mZfsSo, "zpool_get_config"); + mZpoolVdevName = (PFNZPOOLVDEVNAME)(uintptr_t)dlsym(mZfsSo, "zpool_vdev_name"); + + if ( mZfsInit + && mZfsOpen + && mZfsClose + && mZfsPropGetInt + && mZpoolOpen + && mZpoolClose + && mZpoolGetConfig + && mZpoolVdevName) + mZfsLib = mZfsInit(); + else + LogRel(("Incompatible libzfs? libzfs_init=%p zfs_open=%p zfs_close=%p zfs_prop_get_int=%p\n", + mZfsInit, mZfsOpen, mZfsClose, mZfsPropGetInt)); + } + + updateFilesystemMap(); + /* Notice that mCpus member will be initialized by HostCpuLoadRaw::init() */ + + uint64_t cb; + int vrc = RTSystemQueryTotalRam(&cb); + if (RT_FAILURE(vrc)) + totalRAM = 0; + else + totalRAM = (ULONG)(cb / 1024); +} + +CollectorSolaris::~CollectorSolaris() +{ + if (mKC) + kstat_close(mKC); + /* Not calling libzfs_fini() causes file descriptor leaks (#6788). */ + if (mZfsFini && mZfsLib) + mZfsFini(mZfsLib); + if (mZfsSo) + dlclose(mZfsSo); +} + +int CollectorSolaris::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle) +{ + kstat_t *ksp; + uint64_t tmpUser, tmpKernel, tmpIdle; + int cpus; + cpu_stat_t cpu_stats; + + if (mKC == 0) + return VERR_INTERNAL_ERROR; + + tmpUser = tmpKernel = tmpIdle = cpus = 0; + for (ksp = mKC->kc_chain; ksp != NULL; ksp = ksp->ks_next) { + if (strcmp(ksp->ks_module, "cpu_stat") == 0) { + if (kstat_read(mKC, ksp, &cpu_stats) == -1) + { + Log(("kstat_read() -> %d\n", errno)); + return VERR_INTERNAL_ERROR; + } + ++cpus; + tmpUser += cpu_stats.cpu_sysinfo.cpu[CPU_USER]; + tmpKernel += cpu_stats.cpu_sysinfo.cpu[CPU_KERNEL]; + tmpIdle += cpu_stats.cpu_sysinfo.cpu[CPU_IDLE]; + } + } + + if (cpus == 0) + { + Log(("no cpu stats found!\n")); + return VERR_INTERNAL_ERROR; + } + else + mCpus = cpus; + + if (user) *user = tmpUser; + if (kernel) *kernel = tmpKernel; + if (idle) *idle = tmpIdle; + + return VINF_SUCCESS; +} + +int CollectorSolaris::getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total) +{ + int vrc = VINF_SUCCESS; + char *pszName; + prusage_t prusage; + + RTStrAPrintf(&pszName, "/proc/%d/usage", process); + Log(("Opening %s...\n", pszName)); + int h = open(pszName, O_RDONLY); + RTStrFree(pszName); + + if (h != -1) + { + if (read(h, &prusage, sizeof(prusage)) == sizeof(prusage)) + { + //Assert((pid_t)process == pstatus.pr_pid); + //Log(("user=%u kernel=%u total=%u\n", prusage.pr_utime.tv_sec, prusage.pr_stime.tv_sec, prusage.pr_tstamp.tv_sec)); + /* + * The CPU time spent must be adjusted by the number of cores for compatibility with + * other platforms (see @bugref{6345}). + */ + Assert(mCpus); + if (mCpus) + { + *user = ((uint64_t)prusage.pr_utime.tv_sec * 1000000000 + prusage.pr_utime.tv_nsec) / mCpus; + *kernel = ((uint64_t)prusage.pr_stime.tv_sec * 1000000000 + prusage.pr_stime.tv_nsec) / mCpus; + } + else + *user = *kernel = 0; + *total = (uint64_t)prusage.pr_tstamp.tv_sec * 1000000000 + prusage.pr_tstamp.tv_nsec; + //Log(("user=%llu kernel=%llu total=%llu\n", *user, *kernel, *total)); + } + else + { + Log(("read() -> %d\n", errno)); + vrc = VERR_FILE_IO_ERROR; + } + close(h); + } + else + { + Log(("open() -> %d\n", errno)); + vrc = VERR_ACCESS_DENIED; + } + + return vrc; +} + +int CollectorSolaris::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available) +{ + AssertReturn(totalRAM, VERR_INTERNAL_ERROR); + uint64_t cb; + int vrc = RTSystemQueryAvailableRam(&cb); + if (RT_SUCCESS(vrc)) + { + *total = totalRAM; + *available = (ULONG)RT_MIN(cb / 1024, ~(ULONG)0); + *used = *total - *available; + } + return vrc; +} + +int CollectorSolaris::getProcessMemoryUsage(RTPROCESS process, ULONG *used) +{ + int vrc = VINF_SUCCESS; + char *pszName = NULL; + psinfo_t psinfo; + + RTStrAPrintf(&pszName, "/proc/%d/psinfo", process); + Log(("Opening %s...\n", pszName)); + int h = open(pszName, O_RDONLY); + RTStrFree(pszName); + + if (h != -1) + { + /* psinfo_t keeps growing, so only read what we need to maximize + * cross-version compatibility. The structures are compatible. */ + ssize_t cb = RT_UOFFSETOF(psinfo_t, pr_rssize) + RT_SIZEOFMEMB(psinfo_t, pr_rssize); + AssertCompile(RTASSERT_OFFSET_OF(psinfo_t, pr_rssize) > RTASSERT_OFFSET_OF(psinfo_t, pr_pid)); + if (read(h, &psinfo, cb) == cb) + { + Assert((pid_t)process == psinfo.pr_pid); + *used = (ULONG)RT_MIN(psinfo.pr_rssize, ~(ULONG)0); + } + else + { + Log(("read() -> %d\n", errno)); + vrc = VERR_FILE_IO_ERROR; + } + close(h); + } + else + { + Log(("open() -> %d\n", errno)); + vrc = VERR_ACCESS_DENIED; + } + + return vrc; +} + +uint32_t CollectorSolaris::getInstance(const char *pszIfaceName, char *pszDevName) +{ + /* + * Get the instance number from the interface name, then clip it off. + */ + int cbInstance = 0; + size_t cbIface = strlen(pszIfaceName); + const char *pszEnd = pszIfaceName + cbIface - 1; + for (size_t i = 0; i < cbIface - 1; i++) + { + if (!RT_C_IS_DIGIT(*pszEnd)) + break; + cbInstance++; + pszEnd--; + } + + uint32_t uInstance = RTStrToUInt32(pszEnd + 1); + strncpy(pszDevName, pszIfaceName, cbIface - cbInstance); + pszDevName[cbIface - cbInstance] = '\0'; + return uInstance; +} + +uint64_t CollectorSolaris::wrapCorrection(uint32_t cur, uint64_t prev, const char *name) +{ + NOREF(name); + uint64_t corrected = (prev & 0xffffffff00000000) + cur; + if (cur < (prev & 0xffffffff)) + { + /* wrap has occurred */ + corrected += 0x100000000; + LogFlowThisFunc(("Corrected wrap on %s (%u < %u), returned %llu.\n", + name, cur, (uint32_t)prev, corrected)); + } + return corrected; +} + +uint64_t CollectorSolaris::wrapDetection(uint64_t cur, uint64_t prev, const char *name) +{ + if (cur < prev) + LogRelMax(2, ("Detected wrap on %s (%llu < %llu).\n", name, cur, prev)); + return cur; +} + +/* + * WARNING! This function expects the previous values of rx and tx counter to + * be passed in as well as returnes new values in the same parameters. This is + * needed to provide a workaround for 32-bit counter wrapping. + */ +int CollectorSolaris::getRawHostNetworkLoad(const char *name, uint64_t *rx, uint64_t *tx) +{ +#if ARCH_BITS == 32 + static bool g_fNotReported = true; +#endif + AssertReturn(strlen(name) < KSTAT_STRLEN, VERR_INVALID_PARAMETER); + LogFlowThisFunc(("m=%s i=%d n=%s\n", "link", -1, name)); + kstat_t *ksAdapter = kstat_lookup(mKC, (char *)"link", -1, (char *)name); + if (ksAdapter == 0) + { + char szModule[KSTAT_STRLEN]; + uint32_t uInstance = getInstance(name, szModule); + LogFlowThisFunc(("m=%s i=%u n=%s\n", szModule, uInstance, "phys")); + ksAdapter = kstat_lookup(mKC, szModule, uInstance, (char *)"phys"); + if (ksAdapter == 0) + { + LogFlowThisFunc(("m=%s i=%u n=%s\n", szModule, uInstance, name)); + ksAdapter = kstat_lookup(mKC, szModule, uInstance, (char *)name); + if (ksAdapter == 0) + { + static uint32_t s_tsLogRelLast; + uint32_t tsNow = RTTimeProgramSecTS(); + if ( tsNow < RT_SEC_1HOUR + || (tsNow - s_tsLogRelLast >= 60)) + { + s_tsLogRelLast = tsNow; + LogRel(("Failed to get network statistics for %s. Max one msg/min.\n", name)); + } + return VERR_INTERNAL_ERROR; + } + } + } + if (kstat_read(mKC, ksAdapter, 0) == -1) + { + LogRel(("kstat_read(adapter) -> %d\n", errno)); + return VERR_INTERNAL_ERROR; + } + kstat_named_t *kn; + if ((kn = (kstat_named_t *)kstat_data_lookup(ksAdapter, (char *)"rbytes64")) == NULL) + { + if ((kn = (kstat_named_t *)kstat_data_lookup(ksAdapter, (char *)"rbytes")) == NULL) + { + LogRel(("kstat_data_lookup(rbytes) -> %d, name=%s\n", errno, name)); + return VERR_INTERNAL_ERROR; + } +#if ARCH_BITS == 32 + if (g_fNotReported) + { + g_fNotReported = false; + LogRel(("Failed to locate rbytes64, falling back to 32-bit counters...\n")); + } + *rx = wrapCorrection(kn->value.ul, *rx, "rbytes"); +#else + AssertCompile(sizeof(kn->value.ul) == sizeof(uint64_t)); + *rx = wrapDetection(kn->value.ul, *rx, "rbytes"); +#endif + } + else + *rx = wrapDetection(kn->value.ull, *rx, "rbytes64"); + if ((kn = (kstat_named_t *)kstat_data_lookup(ksAdapter, (char *)"obytes64")) == NULL) + { + if ((kn = (kstat_named_t *)kstat_data_lookup(ksAdapter, (char *)"obytes")) == NULL) + { + LogRel(("kstat_data_lookup(obytes) -> %d\n", errno)); + return VERR_INTERNAL_ERROR; + } +#if ARCH_BITS == 32 + if (g_fNotReported) + { + g_fNotReported = false; + LogRel(("Failed to locate obytes64, falling back to 32-bit counters...\n")); + } + *tx = wrapCorrection(kn->value.ul, *tx, "obytes"); +#else + AssertCompile(sizeof(kn->value.ul) == sizeof(uint64_t)); + *tx = wrapDetection(kn->value.ul, *tx, "obytes"); +#endif + } + else + *tx = wrapDetection(kn->value.ull, *tx, "obytes64"); + return VINF_SUCCESS; +} + +int CollectorSolaris::getRawHostDiskLoad(const char *name, uint64_t *disk_ms, uint64_t *total_ms) +{ + int vrc = VINF_SUCCESS; + AssertReturn(strlen(name) < KSTAT_STRLEN, VERR_INVALID_PARAMETER); + LogFlowThisFunc(("n=%s\n", name)); + kstat_t *ksDisk = kstat_lookup(mKC, NULL, -1, (char *)name); + if (ksDisk != 0) + { + if (kstat_read(mKC, ksDisk, 0) == -1) + { + LogRel(("kstat_read(%s) -> %d\n", name, errno)); + vrc = VERR_INTERNAL_ERROR; + } + else + { + kstat_io_t *ksIo = KSTAT_IO_PTR(ksDisk); + /* + * We do not care for wrap possibility here, although we may + * reconsider in about 300 years (9223372036854775807 ns). + */ + *disk_ms = ksIo->rtime / 1000000; + *total_ms = ksDisk->ks_snaptime / 1000000; + } + } + else + { + LogRel(("kstat_lookup(%s) -> %d\n", name, errno)); + vrc = VERR_INTERNAL_ERROR; + } + + return vrc; +} + +uint64_t CollectorSolaris::getZfsTotal(uint64_t cbTotal, const char *szFsType, const char *szFsName) +{ + if (strcmp(szFsType, "zfs")) + return cbTotal; + FsMap::iterator it = mFsMap.find(szFsName); + if (it == mFsMap.end()) + return cbTotal; + + char *pszDataset = strdup(it->second.c_str()); + char *pszEnd = pszDataset + strlen(pszDataset); + uint64_t uAvail = 0; + while (pszEnd) + { + zfs_handle_t *hDataset; + + *pszEnd = 0; + hDataset = mZfsOpen(mZfsLib, pszDataset, ZFS_TYPE_DATASET); + if (!hDataset) + break; + + if (uAvail == 0) + { + uAvail = mZfsPropGetInt(hDataset, ZFS_PROP_REFQUOTA); + if (uAvail == 0) + uAvail = UINT64_MAX; + } + + uint64_t uQuota = mZfsPropGetInt(hDataset, ZFS_PROP_QUOTA); + if (uQuota && uAvail > uQuota) + uAvail = uQuota; + + pszEnd = strrchr(pszDataset, '/'); + if (!pszEnd) + { + uint64_t uPoolSize = mZfsPropGetInt(hDataset, ZFS_PROP_USED) + + mZfsPropGetInt(hDataset, ZFS_PROP_AVAILABLE); + if (uAvail > uPoolSize) + uAvail = uPoolSize; + } + mZfsClose(hDataset); + } + free(pszDataset); + + return uAvail ? uAvail : cbTotal; +} + +int CollectorSolaris::getHostFilesystemUsage(const char *path, ULONG *total, ULONG *used, ULONG *available) +{ + struct statvfs64 stats; + + if (statvfs64(path, &stats) == -1) + { + LogRel(("Failed to collect %s filesystem usage: errno=%d.\n", path, errno)); + return VERR_ACCESS_DENIED; + } + uint64_t cbBlock = stats.f_frsize ? stats.f_frsize : stats.f_bsize; + *total = (ULONG)(getZfsTotal(cbBlock * stats.f_blocks, stats.f_basetype, path) / _1M); + LogFlowThisFunc(("f_blocks=%llu.\n", stats.f_blocks)); + *used = (ULONG)(cbBlock * (stats.f_blocks - stats.f_bfree) / _1M); + *available = (ULONG)(cbBlock * stats.f_bavail / _1M); + + return VINF_SUCCESS; +} + +int CollectorSolaris::getHostDiskSize(const char *name, uint64_t *size) +{ + int vrc = VINF_SUCCESS; + AssertReturn(strlen(name) + 5 < KSTAT_STRLEN, VERR_INVALID_PARAMETER); + LogFlowThisFunc(("n=%s\n", name)); + char szName[KSTAT_STRLEN]; + strcpy(szName, name); + strcat(szName, ",err"); + kstat_t *ksDisk = kstat_lookup(mKC, NULL, -1, szName); + if (ksDisk != 0) + { + if (kstat_read(mKC, ksDisk, 0) == -1) + { + LogRel(("kstat_read(%s) -> %d\n", name, errno)); + vrc = VERR_INTERNAL_ERROR; + } + else + { + kstat_named_t *kn; + if ((kn = (kstat_named_t *)kstat_data_lookup(ksDisk, (char *)"Size")) == 0) + { + LogRel(("kstat_data_lookup(rbytes) -> %d, name=%s\n", errno, name)); + return VERR_INTERNAL_ERROR; + } + *size = kn->value.ull; + } + } + else + { + LogRel(("kstat_lookup(%s) -> %d\n", szName, errno)); + vrc = VERR_INTERNAL_ERROR; + } + + + return vrc; +} + +RTCString CollectorSolaris::physToInstName(const char *pcszPhysName) +{ + FILE *fp = fopen("/etc/path_to_inst", "r"); + if (!fp) + return RTCString(); + + RTCString strInstName; + size_t cbName = strlen(pcszPhysName); + char szBuf[RTPATH_MAX]; + while (fgets(szBuf, sizeof(szBuf), fp)) + { + if (szBuf[0] == '"' && strncmp(szBuf + 1, pcszPhysName, cbName) == 0) + { + char *pszDriver, *pszInstance; + pszDriver = strrchr(szBuf, '"'); + if (pszDriver) + { + *pszDriver = '\0'; + pszDriver = strrchr(szBuf, '"'); + if (pszDriver) + { + *pszDriver++ = '\0'; + pszInstance = strrchr(szBuf, ' '); + if (pszInstance) + { + *pszInstance = '\0'; + pszInstance = strrchr(szBuf, ' '); + if (pszInstance) + { + *pszInstance++ = '\0'; + strInstName = pszDriver; + strInstName += pszInstance; + break; + } + } + } + } + } + } + fclose(fp); + + return strInstName; +} + +RTCString CollectorSolaris::pathToInstName(const char *pcszDevPathName) +{ + char szLink[RTPATH_MAX]; + if (readlink(pcszDevPathName, szLink, sizeof(szLink)) != -1) + { + char *pszStart, *pszEnd; + pszStart = strstr(szLink, "/devices/"); + pszEnd = strrchr(szLink, ':'); + if (pszStart && pszEnd) + { + pszStart += 8; // Skip "/devices" + *pszEnd = '\0'; // Trim partition + return physToInstName(pszStart); + } + } + + return RTCString(pcszDevPathName); +} + +int CollectorSolaris::getDiskListByFs(const char *name, DiskList& listUsage, DiskList& listLoad) +{ + FsMap::iterator it = mFsMap.find(name); + if (it == mFsMap.end()) + return VERR_INVALID_PARAMETER; + + RTCString strName = it->second.substr(0, it->second.find("/")); + if (mZpoolOpen && mZpoolClose && mZpoolGetConfig && !strName.isEmpty()) + { + zpool_handle_t *zh = mZpoolOpen(mZfsLib, strName.c_str()); + if (zh) + { + unsigned int cChildren = 0; + nvlist_t **nvChildren = NULL; + nvlist_t *nvRoot = NULL; + nvlist_t *nvConfig = mZpoolGetConfig(zh, NULL); + if ( !nvlist_lookup_nvlist(nvConfig, ZPOOL_CONFIG_VDEV_TREE, &nvRoot) + && !nvlist_lookup_nvlist_array(nvRoot, ZPOOL_CONFIG_CHILDREN, &nvChildren, &cChildren)) + { + for (unsigned int i = 0; i < cChildren; ++i) + { + uint64_t fHole = 0; + uint64_t fLog = 0; + + nvlist_lookup_uint64(nvChildren[i], ZPOOL_CONFIG_IS_HOLE, &fHole); + nvlist_lookup_uint64(nvChildren[i], ZPOOL_CONFIG_IS_LOG, &fLog); + + if (!fHole && !fLog) + { + char *pszChildName = mZpoolVdevName(mZfsLib, zh, nvChildren[i], _B_FALSE); + Assert(pszChildName); + RTCString strDevPath("/dev/dsk/"); + strDevPath += pszChildName; + char szLink[RTPATH_MAX]; + if (readlink(strDevPath.c_str(), szLink, sizeof(szLink)) != -1) + { + char *pszStart, *pszEnd; + pszStart = strstr(szLink, "/devices/"); + pszEnd = strrchr(szLink, ':'); + if (pszStart && pszEnd) + { + pszStart += 8; // Skip "/devices" + *pszEnd = '\0'; // Trim partition + listUsage.push_back(physToInstName(pszStart)); + } + } + free(pszChildName); + } + } + } + mZpoolClose(zh); + } + } + else + listUsage.push_back(pathToInstName(it->second.c_str())); + listLoad = listUsage; + return VINF_SUCCESS; +} + +void CollectorSolaris::updateFilesystemMap(void) +{ + FILE *fp = fopen("/etc/mnttab", "r"); + if (fp) + { + struct mnttab Entry; + int iRc = 0; + resetmnttab(fp); + while ((iRc = getmntent(fp, &Entry)) == 0) + mFsMap[Entry.mnt_mountp] = Entry.mnt_special; + fclose(fp); + if (iRc != -1) + LogRel(("Error while reading mnttab: %d\n", iRc)); + } +} + +} diff --git a/src/VBox/Main/src-server/solaris/USBProxyBackendSolaris.cpp b/src/VBox/Main/src-server/solaris/USBProxyBackendSolaris.cpp new file mode 100644 index 00000000..c2b6ed8c --- /dev/null +++ b/src/VBox/Main/src-server/solaris/USBProxyBackendSolaris.cpp @@ -0,0 +1,496 @@ +/* $Id: USBProxyBackendSolaris.cpp $ */ +/** @file + * VirtualBox USB Proxy Service, Solaris Specialization. + */ + +/* + * Copyright (C) 2005-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_MAIN_USBPROXYBACKEND +#include "USBProxyBackend.h" +#include "LoggingNew.h" + +#include <VBox/usb.h> +#include <VBox/usblib.h> +#include <iprt/errcore.h> +#include <iprt/semaphore.h> +#include <iprt/path.h> + +#include <sys/usb/usba.h> +#include <syslog.h> + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int solarisWalkDeviceNode(di_node_t Node, void *pvArg); +static void solarisFreeUSBDevice(PUSBDEVICE pDevice); +static USBDEVICESTATE solarisDetermineUSBDeviceState(PUSBDEVICE pDevice, di_node_t Node); + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef struct USBDEVICELIST +{ + PUSBDEVICE pHead; + PUSBDEVICE pTail; +} USBDEVICELIST; +typedef USBDEVICELIST *PUSBDEVICELIST; + + +/** + * Initialize data members. + */ +USBProxyBackendSolaris::USBProxyBackendSolaris() + : USBProxyBackend(), mNotifyEventSem(NIL_RTSEMEVENT), mUSBLibInitialized(false) +{ + LogFlowThisFunc(("\n")); +} + +USBProxyBackendSolaris::~USBProxyBackendSolaris() +{ +} + +/** + * Initializes the object (called right after construction). + * + * @returns VBox status code. + */ +int USBProxyBackendSolaris::init(USBProxyService *aUsbProxyService, const com::Utf8Str &strId, + const com::Utf8Str &strAddress, bool fLoadingSettings) +{ + USBProxyBackend::init(aUsbProxyService, strId, strAddress, fLoadingSettings); + + unconst(m_strBackend) = Utf8Str("host"); + + /* + * Create semaphore. + */ + int vrc = RTSemEventCreate(&mNotifyEventSem); + if (RT_FAILURE(vrc)) + return vrc; + + /* + * Initialize the USB library. + */ + vrc = USBLibInit(); + if (RT_FAILURE(vrc)) + { + /* mNotifyEventSem will be destroyed in uninit */ + return vrc; + } + + mUSBLibInitialized = true; + + /* + * Start the poller thread. + */ + start(); + return VINF_SUCCESS; +} + + +/** + * Stop all service threads and free the device chain. + */ +void USBProxyBackendSolaris::uninit() +{ + LogFlowThisFunc(("destruct\n")); + + /* + * Stop the service. + */ + if (isActive()) + stop(); + + /* + * Terminate the USB library + */ + if (mUSBLibInitialized) + { + USBLibTerm(); + mUSBLibInitialized = false; + } + + if (mNotifyEventSem != NIL_RTSEMEVENT) + { + RTSemEventDestroy(mNotifyEventSem); + mNotifyEventSem = NIL_RTSEMEVENT; + } +} + + +void *USBProxyBackendSolaris::insertFilter(PCUSBFILTER aFilter) +{ + return USBLibAddFilter(aFilter); +} + + +void USBProxyBackendSolaris::removeFilter(void *pvID) +{ + USBLibRemoveFilter(pvID); +} + + +int USBProxyBackendSolaris::wait(RTMSINTERVAL aMillies) +{ + return RTSemEventWait(mNotifyEventSem, aMillies < 1000 ? 1000 : RT_MIN(aMillies, 5000)); +} + + +int USBProxyBackendSolaris::interruptWait(void) +{ + return RTSemEventSignal(mNotifyEventSem); +} + + +PUSBDEVICE USBProxyBackendSolaris::getDevices(void) +{ + USBDEVICELIST DevList; + DevList.pHead = NULL; + DevList.pTail = NULL; + di_node_t RootNode = di_init("/", DINFOCPYALL); + if (RootNode != DI_NODE_NIL) + di_walk_node(RootNode, DI_WALK_CLDFIRST, &DevList, solarisWalkDeviceNode); + + di_fini(RootNode); + return DevList.pHead; +} + + +static int solarisWalkDeviceNode(di_node_t Node, void *pvArg) +{ + PUSBDEVICELIST pList = (PUSBDEVICELIST)pvArg; + AssertPtrReturn(pList, DI_WALK_TERMINATE); + + /* + * Check if it's a USB device in the first place. + */ + bool fUSBDevice = false; + char *pszCompatNames = NULL; + int cCompatNames = di_compatible_names(Node, &pszCompatNames); + for (int i = 0; i < cCompatNames; i++, pszCompatNames += strlen(pszCompatNames) + 1) + if (!strncmp(pszCompatNames, RT_STR_TUPLE("usb"))) + { + fUSBDevice = true; + break; + } + + if (!fUSBDevice) + return DI_WALK_CONTINUE; + + /* + * Check if it's a device node or interface. + */ + int *pInt = NULL; + char *pStr = NULL; + int iRc = DI_WALK_CONTINUE; + if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "interface", &pInt) < 0) + { + /* It's a device node. */ + char *pszDevicePath = di_devfs_path(Node); + PUSBDEVICE pCur = (PUSBDEVICE)RTMemAllocZ(sizeof(*pCur)); + if (!pCur) + { + LogRel(("USBService: failed to allocate %d bytes for PUSBDEVICE.\n", sizeof(*pCur))); + return DI_WALK_TERMINATE; + } + + bool fValidDevice = false; + do + { + AssertBreak(pszDevicePath); + + char *pszDriverName = di_driver_name(Node); + + /* + * Skip hubs + */ + if ( pszDriverName + && !strcmp(pszDriverName, "hubd")) + { + break; + } + + /* + * Mandatory. + * snv_85 and above have usb-dev-descriptor node properties, but older one's do not. + * So if we cannot obtain the entire device descriptor, we try falling back to the + * individual properties (those must not fail, if it does we drop the device). + */ + uchar_t *pDevData = NULL; + int cbProp = di_prop_lookup_bytes(DDI_DEV_T_ANY, Node, "usb-dev-descriptor", &pDevData); + if ( cbProp > 0 + && pDevData) + { + usb_dev_descr_t *pDeviceDescriptor = (usb_dev_descr_t *)pDevData; + pCur->bDeviceClass = pDeviceDescriptor->bDeviceClass; + pCur->bDeviceSubClass = pDeviceDescriptor->bDeviceSubClass; + pCur->bDeviceProtocol = pDeviceDescriptor->bDeviceProtocol; + pCur->idVendor = pDeviceDescriptor->idVendor; + pCur->idProduct = pDeviceDescriptor->idProduct; + pCur->bcdDevice = pDeviceDescriptor->bcdDevice; + pCur->bcdUSB = pDeviceDescriptor->bcdUSB; + pCur->bNumConfigurations = pDeviceDescriptor->bNumConfigurations; + pCur->fPartialDescriptor = false; + } + else + { + AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-vendor-id", &pInt) > 0); + pCur->idVendor = (uint16_t)*pInt; + + AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-product-id", &pInt) > 0); + pCur->idProduct = (uint16_t)*pInt; + + AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-revision-id", &pInt) > 0); + pCur->bcdDevice = (uint16_t)*pInt; + + AssertBreak(di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "usb-release", &pInt) > 0); + pCur->bcdUSB = (uint16_t)*pInt; + + pCur->fPartialDescriptor = true; + } + + char *pszPortAddr = di_bus_addr(Node); + if (pszPortAddr) + pCur->bPort = RTStrToUInt8(pszPortAddr); /* Bus & Port are mixed up (kernel driver/userland) */ + else + pCur->bPort = 0; + + char szBuf[PATH_MAX + 48]; + RTStrPrintf(szBuf, sizeof(szBuf), "%#x:%#x:%d:%s", pCur->idVendor, pCur->idProduct, pCur->bcdDevice, pszDevicePath); + pCur->pszAddress = RTStrDup(szBuf); + AssertBreak(pCur->pszAddress); + + pCur->pszDevicePath = RTStrDup(pszDevicePath); + AssertBreak(pCur->pszDevicePath); + + pCur->pszBackend = RTStrDup("host"); + AssertBreak(pCur->pszBackend); + + /* + * Optional (some devices don't have all these) + */ + char *pszCopy; + if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "usb-product-name", &pStr) > 0) + { + pCur->pszProduct = pszCopy = RTStrDup(pStr); + USBLibPurgeEncoding(pszCopy); + } + + if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "usb-vendor-name", &pStr) > 0) + { + pCur->pszManufacturer = pszCopy = RTStrDup(pStr); + USBLibPurgeEncoding(pszCopy); + } + + if (di_prop_lookup_strings(DDI_DEV_T_ANY, Node, "usb-serialno", &pStr) > 0) + { + pCur->pszSerialNumber = pszCopy = RTStrDup(pStr); + USBLibPurgeEncoding(pszCopy); + } + + if (pCur->bcdUSB == 0x300) + pCur->enmSpeed = USBDEVICESPEED_SUPER; + else if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "low-speed", &pInt) >= 0) + pCur->enmSpeed = USBDEVICESPEED_LOW; + else if (di_prop_lookup_ints(DDI_DEV_T_ANY, Node, "high-speed", &pInt) >= 0) + pCur->enmSpeed = USBDEVICESPEED_HIGH; + else + pCur->enmSpeed = USBDEVICESPEED_FULL; + + /* Determine state of the USB device. */ + pCur->enmState = solarisDetermineUSBDeviceState(pCur, Node); + + /* + * Valid device, add it to the list. + */ + fValidDevice = true; + pCur->pPrev = pList->pTail; + if (pList->pTail) + pList->pTail = pList->pTail->pNext = pCur; + else + pList->pTail = pList->pHead = pCur; + + iRc = DI_WALK_CONTINUE; + } while (0); + + di_devfs_path_free(pszDevicePath); + if (!fValidDevice) + solarisFreeUSBDevice(pCur); + } + return iRc; +} + + +static USBDEVICESTATE solarisDetermineUSBDeviceState(PUSBDEVICE pDevice, di_node_t Node) +{ + char *pszDriverName = di_driver_name(Node); + + /* Not possible unless a user explicitly unbinds the default driver. */ + if (!pszDriverName) + return USBDEVICESTATE_UNUSED; + + if (!strncmp(pszDriverName, RT_STR_TUPLE(VBOXUSB_DRIVER_NAME))) + return USBDEVICESTATE_HELD_BY_PROXY; + + NOREF(pDevice); + return USBDEVICESTATE_USED_BY_HOST_CAPTURABLE; +} + + +int USBProxyBackendSolaris::captureDevice(HostUSBDevice *aDevice) +{ + /* + * Check preconditions. + */ + AssertReturn(aDevice, VERR_GENERAL_FAILURE); + AssertReturn(!aDevice->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE); + + AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS); + LogFlowThisFunc(("aDevice=%s\n", aDevice->i_getName().c_str())); + + Assert(aDevice->i_getUnistate() == kHostUSBDeviceState_Capturing); + AssertReturn(aDevice->i_getUsbData(), VERR_INVALID_POINTER); + + /* + * Create a one-shot capture filter for the device and reset the device. + */ + USBFILTER Filter; + USBFilterInit(&Filter, USBFILTERTYPE_ONESHOT_CAPTURE); + initFilterFromDevice(&Filter, aDevice); + + void *pvId = USBLibAddFilter(&Filter); + if (!pvId) + { + LogRel(("USBService: failed to add filter\n")); + return VERR_GENERAL_FAILURE; + } + + PUSBDEVICE pDev = aDevice->i_getUsbData(); + int vrc = USBLibResetDevice(pDev->pszDevicePath, true); + if (RT_SUCCESS(vrc)) + aDevice->i_setBackendUserData(pvId); + else + { + USBLibRemoveFilter(pvId); + pvId = NULL; + } + LogFlowThisFunc(("returns %Rrc pvId=%p\n", vrc, pvId)); + return vrc; +} + + +void USBProxyBackendSolaris::captureDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess) +{ + AssertReturnVoid(aDevice->isWriteLockOnCurrentThread()); + /* + * Remove the one-shot filter if necessary. + */ + LogFlowThisFunc(("aDevice=%s aSuccess=%RTbool mOneShotId=%p\n", aDevice->i_getName().c_str(), aSuccess, aDevice->i_getBackendUserData())); + if (!aSuccess && aDevice->i_getBackendUserData()) + USBLibRemoveFilter(aDevice->i_getBackendUserData()); + aDevice->i_setBackendUserData(NULL); + USBProxyBackend::captureDeviceCompleted(aDevice, aSuccess); +} + + +int USBProxyBackendSolaris::releaseDevice(HostUSBDevice *aDevice) +{ + /* + * Check preconditions. + */ + AssertReturn(aDevice, VERR_GENERAL_FAILURE); + AssertReturn(!aDevice->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE); + + AutoReadLock devLock(aDevice COMMA_LOCKVAL_SRC_POS); + LogFlowThisFunc(("aDevice=%s\n", aDevice->i_getName().c_str())); + + Assert(aDevice->i_getUnistate() == kHostUSBDeviceState_ReleasingToHost); + AssertReturn(aDevice->i_getUsbData(), VERR_INVALID_POINTER); + + /* + * Create a one-shot ignore filter for the device and reset it. + */ + USBFILTER Filter; + USBFilterInit(&Filter, USBFILTERTYPE_ONESHOT_IGNORE); + initFilterFromDevice(&Filter, aDevice); + + void *pvId = USBLibAddFilter(&Filter); + if (!pvId) + { + LogRel(("USBService: Adding ignore filter failed!\n")); + return VERR_GENERAL_FAILURE; + } + + PUSBDEVICE pDev = aDevice->i_getUsbData(); + int vrc = USBLibResetDevice(pDev->pszDevicePath, true /* Re-attach */); + if (RT_SUCCESS(vrc)) + aDevice->i_setBackendUserData(pvId); + else + { + USBLibRemoveFilter(pvId); + pvId = NULL; + } + LogFlowThisFunc(("returns %Rrc pvId=%p\n", vrc, pvId)); + return vrc; +} + + +void USBProxyBackendSolaris::releaseDeviceCompleted(HostUSBDevice *aDevice, bool aSuccess) +{ + AssertReturnVoid(aDevice->isWriteLockOnCurrentThread()); + /* + * Remove the one-shot filter if necessary. + */ + LogFlowThisFunc(("aDevice=%s aSuccess=%RTbool mOneShotId=%p\n", aDevice->i_getName().c_str(), aSuccess, aDevice->i_getBackendUserData())); + if (!aSuccess && aDevice->i_getBackendUserData()) + USBLibRemoveFilter(aDevice->i_getBackendUserData()); + aDevice->i_setBackendUserData(NULL); + USBProxyBackend::releaseDeviceCompleted(aDevice, aSuccess); +} + + +/** + * Returns whether devices reported by this backend go through a de/re-attach + * and device re-enumeration cycle when they are captured or released. + */ +bool USBProxyBackendSolaris::i_isDevReEnumerationRequired() +{ + return true; +} + + +/** + * Wrapper called by walkDeviceNode. + * + * @param pDevice The USB device to free. + */ +void solarisFreeUSBDevice(PUSBDEVICE pDevice) +{ + USBProxyBackend::freeDevice(pDevice); +} |