/**
* Create a User-kernel heap.
*
* This does not require SUPLib to be initialized as we'll lazily allocate the
* kernel accessible memory on the first alloc call.
*
* @returns VBox status code.
* @param pUVM Pointer to the user mode VM structure.
* @param ppHeap Where to store the heap pointer.
*/
int mmR3UkHeapCreateU(PUVM pUVM, PMMUKHEAP *ppHeap)
{
PMMUKHEAP pHeap = (PMMUKHEAP)MMR3HeapAllocZU(pUVM, MM_TAG_MM, sizeof(MMUKHEAP));
if (pHeap)
{
int rc = RTCritSectInit(&pHeap->Lock);
if (RT_SUCCESS(rc))
{
/*
* Initialize the global stat record.
*/
pHeap->pUVM = pUVM;
#ifdef MMUKHEAP_WITH_STATISTICS
PMMUKHEAPSTAT pStat = &pHeap->Stat;
STAMR3RegisterU(pUVM, &pStat->cAllocations, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cAllocations", STAMUNIT_CALLS, "Number or MMR3UkHeapAlloc() calls.");
STAMR3RegisterU(pUVM, &pStat->cReallocations, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cReallocations", STAMUNIT_CALLS, "Number of MMR3UkHeapRealloc() calls.");
STAMR3RegisterU(pUVM, &pStat->cFrees, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cFrees", STAMUNIT_CALLS, "Number of MMR3UkHeapFree() calls.");
STAMR3RegisterU(pUVM, &pStat->cFailures, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cFailures", STAMUNIT_COUNT, "Number of failures.");
STAMR3RegisterU(pUVM, &pStat->cbCurAllocated, sizeof(pStat->cbCurAllocated) == sizeof(uint32_t) ? STAMTYPE_U32 : STAMTYPE_U64,
STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cbCurAllocated", STAMUNIT_BYTES, "Number of bytes currently allocated.");
STAMR3RegisterU(pUVM, &pStat->cbAllocated, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cbAllocated", STAMUNIT_BYTES, "Total number of bytes allocated.");
STAMR3RegisterU(pUVM, &pStat->cbFreed, STAMTYPE_U64, STAMVISIBILITY_ALWAYS, "/MM/UkHeap/cbFreed", STAMUNIT_BYTES, "Total number of bytes freed.");
#endif
*ppHeap = pHeap;
return VINF_SUCCESS;
}
AssertRC(rc);
MMR3HeapFree(pHeap);
}
AssertMsgFailed(("failed to allocate heap structure\n"));
return VERR_NO_MEMORY;
}
AutostartDb::AutostartDb()
{
#ifdef RT_OS_LINUX
int rc = RTCritSectInit(&this->CritSect);
NOREF(rc);
m_pszAutostartDbPath = NULL;
#endif
}
EventQueue::EventQueue(void)
: mUserCnt(0),
mShutdown(false)
{
int rc = RTCritSectInit(&mCritSect);
AssertRC(rc);
rc = RTSemEventCreate(&mSemEvent);
AssertRC(rc);
}
RTDECL(int) RTLocalIpcServerCreate(PRTLOCALIPCSERVER phServer, const char *pszName, uint32_t fFlags)
{
/*
* Basic parameter validation.
*/
AssertPtrReturn(phServer, VERR_INVALID_POINTER);
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertReturn(*pszName, VERR_INVALID_PARAMETER);
AssertReturn(!(fFlags & ~(RTLOCALIPC_FLAGS_VALID_MASK)), VERR_INVALID_PARAMETER);
AssertReturn((fFlags & RTLOCALIPC_FLAGS_MULTI_SESSION), VERR_INVALID_PARAMETER); /** @todo Implement !RTLOCALIPC_FLAGS_MULTI_SESSION */
/*
* Allocate and initialize the instance data.
*/
size_t cchName = strlen(pszName);
size_t cch = RT_OFFSETOF(RTLOCALIPCSERVERINT, szName[cchName + sizeof(RTLOCALIPC_WIN_PREFIX)]);
PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)RTMemAlloc(cch);
if (!pThis)
return VERR_NO_MEMORY;
pThis->u32Magic = RTLOCALIPCSERVER_MAGIC;
pThis->cRefs = 1; /* the one we return */
pThis->fCancelled = false;
memcpy(pThis->szName, RTLOCALIPC_WIN_PREFIX, sizeof(RTLOCALIPC_WIN_PREFIX) - 1);
memcpy(&pThis->szName[sizeof(RTLOCALIPC_WIN_PREFIX) - 1], pszName, cchName + 1);
int rc = RTCritSectInit(&pThis->CritSect);
if (RT_SUCCESS(rc))
{
pThis->hEvent = CreateEvent(NULL /*lpEventAttributes*/, TRUE /*bManualReset*/,
FALSE /*bInitialState*/, NULL /*lpName*/);
if (pThis->hEvent != NULL)
{
RT_ZERO(pThis->OverlappedIO);
pThis->OverlappedIO.Internal = STATUS_PENDING;
pThis->OverlappedIO.hEvent = pThis->hEvent;
rc = rtLocalIpcServerWinCreatePipeInstance(&pThis->hNmPipe,
pThis->szName, true /* fFirst */);
if (RT_SUCCESS(rc))
{
*phServer = pThis;
return VINF_SUCCESS;
}
BOOL fRc = CloseHandle(pThis->hEvent);
AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
}
else
rc = RTErrConvertFromWin32(GetLastError());
int rc2 = RTCritSectDelete(&pThis->CritSect);
AssertRC(rc2);
}
RTMemFree(pThis);
return rc;
}
VBoxSDSPerUserData(com::Utf8Str const &a_rStrUserSid, com::Utf8Str const &a_rStrUsername)
: m_strUserSid(a_rStrUserSid)
, m_strUsername(a_rStrUsername)
#ifdef WITH_WATCHER
, m_iWatcher(UINT32_MAX)
, m_iTheChosenOneRevision(0)
#endif
, m_pidTheChosenOne(NIL_RTPROCESS)
, m_cRefs(1)
{
RTCritSectInit(&m_Lock);
}
GLboolean renderspuWindowInit( WindowInfo *window, VisualInfo *visual, GLboolean showIt, GLint id )
{
crMemset(window, 0, sizeof (*window));
RTCritSectInit(&window->CompositorLock);
window->fCompositorPresentEmpty = GL_FALSE;
window->pCompositor = NULL;
window->BltInfo.Base.id = id;
window->x = render_spu.defaultX;
window->y = render_spu.defaultY;
window->BltInfo.width = render_spu.defaultWidth;
window->BltInfo.height = render_spu.defaultHeight;
/* Set window->title, replacing %i with the window ID number */
{
const char *s = crStrstr(render_spu.window_title, "%i");
if (s) {
int i, j, k;
window->title = crAlloc(crStrlen(render_spu.window_title) + 10);
for (i = 0; render_spu.window_title[i] != '%'; i++)
window->title[i] = render_spu.window_title[i];
k = sprintf(window->title + i, "%d", window->BltInfo.Base.id);
CRASSERT(k < 10);
i++; /* skip the 'i' after the '%' */
j = i + k;
for (; (window->title[j] = s[i]) != 0; i++, j++)
;
}
else {
window->title = crStrdup(render_spu.window_title);
}
}
window->BltInfo.Base.visualBits = visual->visAttribs;
/*
crDebug("Render SPU: Creating window (visBits=0x%x, id=%d)", visBits, window->BltInfo.Base.id);
*/
/* Have GLX/WGL/AGL create the window */
if (!renderspu_SystemVBoxCreateWindow( visual, showIt, window ))
{
crWarning( "Render SPU: Couldn't create a window, renderspu_SystemCreateWindow failed" );
return GL_FALSE;
}
window->visible = !!showIt;
CRASSERT(window->visual == visual);
return GL_TRUE;
}
UIFrameBuffer::UIFrameBuffer(UIMachineView *pMachineView)
: m_pMachineView(pMachineView)
, m_width(0), m_height(0)
, m_fIsDeleted(false)
#if defined (Q_OS_WIN32)
, m_iRefCnt(0)
#endif
{
AssertMsg(m_pMachineView, ("UIMachineView must not be null\n"));
m_WinId = (m_pMachineView && m_pMachineView->viewport()) ? (LONG64)m_pMachineView->viewport()->winId() : 0;
int rc = RTCritSectInit(&m_critSect);
AssertRC(rc);
}
/**
* Run once function that initializes the kstats we need here.
*
* @returns IPRT status code.
* @param pvUser1 Unused.
* @param pvUser2 Unused.
*/
static DECLCALLBACK(int) rtMpSolarisOnce(void *pvUser1, void *pvUser2)
{
int rc = VINF_SUCCESS;
NOREF(pvUser1); NOREF(pvUser2);
/*
* Open kstat and find the cpu_info entries for each of the CPUs.
*/
g_pKsCtl = kstat_open();
if (g_pKsCtl)
{
g_capCpuInfo = RTMpGetCount();
g_papCpuInfo = (kstat_t **)RTMemAllocZ(g_capCpuInfo * sizeof(kstat_t *));
if (g_papCpuInfo)
{
rc = RTCritSectInit(&g_MpSolarisCritSect);
if (RT_SUCCESS(rc))
{
RTCPUID i = 0;
for (kstat_t *pKsp = g_pKsCtl->kc_chain; pKsp != NULL; pKsp = pKsp->ks_next)
{
if (!strcmp(pKsp->ks_module, "cpu_info"))
{
AssertBreak(i < g_capCpuInfo);
g_papCpuInfo[i++] = pKsp;
/** @todo ks_instance == cpu_id (/usr/src/uts/common/os/cpu.c)? Check this and fix it ASAP. */
}
}
return VINF_SUCCESS;
}
/* bail out, we failed. */
RTMemFree(g_papCpuInfo);
}
else
rc = VERR_NO_MEMORY;
kstat_close(g_pKsCtl);
g_pKsCtl = NULL;
}
else
{
rc = RTErrConvertFromErrno(errno);
if (RT_SUCCESS(rc))
rc = VERR_INTERNAL_ERROR;
Log(("kstat_open() -> %d (%Rrc)\n", errno, rc));
}
return rc;
}
static int pdmNsBwGroupCreate(PPDMNETSHAPER pShaper, const char *pcszBwGroup, uint64_t cbTransferPerSecMax)
{
LogFlowFunc(("pShaper=%#p pcszBwGroup=%#p{%s} cbTransferPerSecMax=%u\n",
pShaper, pcszBwGroup, pcszBwGroup, cbTransferPerSecMax));
AssertPtrReturn(pShaper, VERR_INVALID_POINTER);
AssertPtrReturn(pcszBwGroup, VERR_INVALID_POINTER);
AssertReturn(*pcszBwGroup != '\0', VERR_INVALID_PARAMETER);
int rc;
PPDMNSBWGROUP pBwGroup = pdmNsBwGroupFindById(pShaper, pcszBwGroup);
if (!pBwGroup)
{
rc = MMR3HeapAllocZEx(pShaper->pVM, MM_TAG_PDM_NET_SHAPER,
sizeof(PDMNSBWGROUP),
(void **)&pBwGroup);
if (RT_SUCCESS(rc))
{
rc = RTCritSectInit(&pBwGroup->cs);
if (RT_SUCCESS(rc))
{
pBwGroup->pszName = RTStrDup(pcszBwGroup);
if (pBwGroup->pszName)
{
pBwGroup->pShaper = pShaper;
pBwGroup->cRefs = 0;
pdmNsBwGroupSetLimit(pBwGroup, cbTransferPerSecMax);
;
pBwGroup->cbTokensLast = pBwGroup->cbBucketSize;
pBwGroup->tsUpdatedLast = RTTimeSystemNanoTS();
LogFlowFunc(("pcszBwGroup={%s} cbBucketSize=%u\n",
pcszBwGroup, pBwGroup->cbBucketSize));
pdmNsBwGroupLink(pBwGroup);
return VINF_SUCCESS;
}
RTCritSectDelete(&pBwGroup->cs);
}
MMR3HeapFree(pBwGroup);
}
else
rc = VERR_NO_MEMORY;
}
else
rc = VERR_ALREADY_EXISTS;
LogFlowFunc(("returns rc=%Rrc\n", rc));
return rc;
}
HRESULT VirtualBoxSDS::FinalConstruct()
{
LogRelFlowThisFuncEnter();
int vrc = RTCritSectRwInit(&m_MapCritSect);
AssertLogRelRCReturn(vrc, E_FAIL);
#ifdef WITH_WATCHER
vrc = RTCritSectInit(&m_WatcherCritSect);
AssertLogRelRCReturn(vrc, E_FAIL);
#endif
LogRelFlowThisFuncLeave();
return S_OK;
}
/**
* Create a session instance.
*
* @returns IPRT status code.
*
* @param phClientSession Where to store the session handle on success.
* @param hNmPipeSession The named pipe handle. This will be consumed by this session, meaning on failure
* to create the session it will be closed.
*/
static int rtLocalIpcWinCreateSession(PRTLOCALIPCSESSION phClientSession, HANDLE hNmPipeSession)
{
AssertPtrReturn(phClientSession, VERR_INVALID_POINTER);
AssertReturn(hNmPipeSession != INVALID_HANDLE_VALUE, VERR_INVALID_HANDLE);
int rc;
/*
* Allocate and initialize the session instance data.
*/
PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)RTMemAlloc(sizeof(*pThis));
if (pThis)
{
pThis->u32Magic = RTLOCALIPCSESSION_MAGIC;
pThis->cRefs = 1; /* our ref */
pThis->fCancelled = false;
pThis->fIOPending = false;
pThis->fZeroByteRead = false;
pThis->hNmPipe = hNmPipeSession;
rc = RTCritSectInit(&pThis->CritSect);
if (RT_SUCCESS(rc))
{
pThis->hEvent = CreateEvent(NULL /*lpEventAttributes*/, TRUE /*bManualReset*/,
FALSE /*bInitialState*/, NULL /*lpName*/);
if (pThis->hEvent != NULL)
{
RT_ZERO(pThis->OverlappedIO);
pThis->OverlappedIO.Internal = STATUS_PENDING;
pThis->OverlappedIO.hEvent = pThis->hEvent;
*phClientSession = pThis;
return VINF_SUCCESS;
}
/* bail out */
rc = RTErrConvertFromWin32(GetLastError());
RTCritSectDelete(&pThis->CritSect);
}
RTMemFree(pThis);
}
else
rc = VERR_NO_MEMORY;
BOOL fRc = CloseHandle(hNmPipeSession);
AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
return rc;
}
/**
* Initialize the port to IPRT.
*/
void sys_init(void)
{
int rc;
unsigned i;
#if SYS_LIGHTWEIGHT_PROT
rc = RTCritSectInit(&g_ProtCritSect);
AssertRC(rc);
#else
rc = RTSemEventCreate(&g_ThreadSem);
AssertRC(rc);
rc = RTSemEventSignal(g_ThreadSem);
AssertRC(rc);
#endif
for (i = 0; i < THREADS_MAX; i++)
g_aTLS[i].tid = NIL_RTTHREAD;
}
int hgcmObjInit (void)
{
int rc = VINF_SUCCESS;
LogFlow(("MAIN::hgcmObjInit\n"));
g_u32InternalHandleCount = 0x80000000;
g_u32ClientHandleCount = 0;
g_pTree = NULL;
rc = RTCritSectInit (&g_critsect);
LogFlow(("MAIN::hgcmObjInit: rc = %Rrc\n", rc));
return rc;
}
/**
* Creates a module based on the default debug info container.
*
* This can be used to manually load a module and its symbol. The primary user
* group is the debug info interpreters, which use this API to create an
* efficient debug info container behind the scenes and forward all queries to
* it once the info has been loaded.
*
* @returns IPRT status code.
*
* @param phDbgMod Where to return the module handle.
* @param pszName The name of the module (mandatory).
* @param cbSeg The size of initial segment. If zero, segments will
* have to be added manually using RTDbgModSegmentAdd.
* @param fFlags Flags reserved for future extensions, MBZ for now.
*/
RTDECL(int) RTDbgModCreate(PRTDBGMOD phDbgMod, const char *pszName, RTUINTPTR cbSeg, uint32_t fFlags)
{
/*
* Input validation and lazy initialization.
*/
AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
*phDbgMod = NIL_RTDBGMOD;
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertReturn(*pszName, VERR_INVALID_PARAMETER);
AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER);
int rc = rtDbgModLazyInit();
if (RT_FAILURE(rc))
return rc;
/*
* Allocate a new module instance.
*/
PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
if (!pDbgMod)
return VERR_NO_MEMORY;
pDbgMod->u32Magic = RTDBGMOD_MAGIC;
pDbgMod->cRefs = 1;
rc = RTCritSectInit(&pDbgMod->CritSect);
if (RT_SUCCESS(rc))
{
pDbgMod->pszName = RTStrCacheEnter(g_hDbgModStrCache, pszName);
if (pDbgMod->pszName)
{
rc = rtDbgModContainerCreate(pDbgMod, cbSeg);
if (RT_SUCCESS(rc))
{
*phDbgMod = pDbgMod;
return rc;
}
RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
}
RTCritSectDelete(&pDbgMod->CritSect);
}
RTMemFree(pDbgMod);
return rc;
}
/**
* Allocates a new node and initialize the node part of it.
*
* The returned node has one reference.
*
* @returns VBox status code.
*
* @param cbNode The size of the node.
* @param pszName The name of the node.
* @param enmType The node type.
* @param pDir The directory (parent).
* @param ppNode Where to return the pointer to the node.
*/
static int vboxfuseNodeAlloc(size_t cbNode, const char *pszName, VBOXFUSETYPE enmType, PVBOXFUSEDIR pDir,
PVBOXFUSENODE *ppNode)
{
Assert(cbNode >= sizeof(VBOXFUSENODE));
/*
* Allocate the memory for it and init the critical section.
*/
size_t cchName = strlen(pszName);
PVBOXFUSENODE pNode = (PVBOXFUSENODE)RTMemAlloc(cchName + 1 + RT_ALIGN_Z(cbNode, 8));
if (!pNode)
return VERR_NO_MEMORY;
int rc = RTCritSectInit(&pNode->CritSect);
if (RT_FAILURE(rc))
{
RTMemFree(pNode);
return rc;
}
/*
* Initialize the members.
*/
pNode->pszName = (char *)memcpy((uint8_t *)pNode + RT_ALIGN_Z(cbNode, 8), pszName, cchName + 1);
pNode->cchName = cchName;
pNode->enmType = enmType;
pNode->cRefs = 1;
pNode->pDir = pDir;
#if 0
pNode->fMode = enmType == VBOXFUSETYPE_DIRECTORY ? S_IFDIR | 0755 : S_IFREG | 0644;
#else
pNode->fMode = enmType == VBOXFUSETYPE_DIRECTORY ? S_IFDIR | 0777 : S_IFREG | 0666;
#endif
pNode->Uid = 0;
pNode->Gid = 0;
pNode->cLinks = 0;
pNode->Ino = g_NextIno++; /** @todo make this safe! */
pNode->cbPrimary = 0;
*ppNode = pNode;
return VINF_SUCCESS;
}
UIFrameBuffer::UIFrameBuffer(UIMachineView *pMachineView)
: m_pMachineView(pMachineView)
, m_width(0), m_height(0)
, m_fIsScheduledToDelete(false)
#ifdef Q_OS_WIN
, m_iRefCnt(0)
#endif /* Q_OS_WIN */
{
/* Assign mahine-view: */
AssertMsg(m_pMachineView, ("UIMachineView must not be null\n"));
m_WinId = (m_pMachineView && m_pMachineView->viewport()) ? (LONG64)m_pMachineView->viewport()->winId() : 0;
/* Connect handlers: */
if (m_pMachineView)
prepareConnections();
/* Initialize critical-section: */
int rc = RTCritSectInit(&m_critSect);
AssertRC(rc);
}
RemoteUSBBackend::RemoteUSBBackend(Console *console, ConsoleVRDPServer *server, uint32_t u32ClientId)
:
mConsole(console),
mServer(server),
cRefs(0),
mu32ClientId(u32ClientId),
mfHasDeviceList(false),
mpvDeviceList(NULL),
mcbDeviceList(0),
menmPollRemoteDevicesStatus(PollRemoteDevicesStatus_Negotiate),
mfPollURB(true),
mpDevices(NULL),
mfWillBeDeleted(false),
mClientVersion(0), /* VRDE_USB_VERSION_2: the client version. */
mfDescExt(false) /* VRDE_USB_VERSION_3: VRDE_USB_REQ_DEVICE_LIST_EXT_RET. */
{
Assert(console);
Assert(server);
int rc = RTCritSectInit(&mCritsect);
if (RT_FAILURE(rc))
{
AssertFailed();
RT_ZERO(mCritsect);
}
mCallback.pInstance = (PREMOTEUSBBACKEND)this;
mCallback.pfnOpen = iface_Open;
mCallback.pfnClose = iface_Close;
mCallback.pfnReset = iface_Reset;
mCallback.pfnSetConfig = iface_SetConfig;
mCallback.pfnClaimInterface = iface_ClaimInterface;
mCallback.pfnReleaseInterface = iface_ReleaseInterface;
mCallback.pfnInterfaceSetting = iface_InterfaceSetting;
mCallback.pfnQueueURB = iface_QueueURB;
mCallback.pfnReapURB = iface_ReapURB;
mCallback.pfnClearHaltedEP = iface_ClearHaltedEP;
mCallback.pfnCancelURB = iface_CancelURB;
mCallback.pfnWakeup = iface_Wakeup;
}
VBoxNetBaseService::VBoxNetBaseService()
{
int rc = RTCritSectInit(&m_csThis);
AssertRC(rc);
/* numbers from DrvIntNet */
m_cbSendBuf = 128 * _1K;
m_cbRecvBuf = 256 * _1K;
m_hIf = INTNET_HANDLE_INVALID;
m_pIfBuf = NULL;
m_cVerbosity = 0;
m_Name = "VBoxNetNAT";
m_Network = "intnet";
for(unsigned int i = 0; i < RT_ELEMENTS(g_aGetOptDef); ++i)
m_vecOptionDefs.push_back(&g_aGetOptDef[i]);
HRESULT hrc = virtualbox.createLocalObject(CLSID_VirtualBox);
if (FAILED(hrc))
RTMsgError("Failed to create the VirtualBox object!");
}
static int svcInit (void)
{
int rc = RTCritSectInit (&critsect);
if (RT_SUCCESS (rc))
{
vboxSvcClipboardModeSet (VBOX_SHARED_CLIPBOARD_MODE_OFF);
rc = vboxClipboardInit ();
/* Clean up on failure, because 'svnUnload' will not be called
* if the 'svcInit' returns an error.
*/
if (RT_FAILURE (rc))
{
RTCritSectDelete (&critsect);
}
}
return rc;
}
/**
* Initialize the info handlers.
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
*/
int dbgfR3InfoInit(PVM pVM)
{
/*
* Make sure we already didn't initialized in the lazy manner.
*/
if (RTCritSectIsInitialized(&pVM->dbgf.s.InfoCritSect))
return VINF_SUCCESS;
/*
* Initialize the crit sect.
*/
int rc = RTCritSectInit(&pVM->dbgf.s.InfoCritSect);
AssertRCReturn(rc, rc);
/*
* Register the 'info help' item.
*/
rc = DBGFR3InfoRegisterInternal(pVM, "help", "List of info items.", dbgfR3InfoHelp);
AssertRCReturn(rc, rc);
return VINF_SUCCESS;
}
/**
* SDL framebuffer constructor. It is called from the main
* (i.e. SDL) thread. Therefore it is safe to use SDL calls
* here.
*/
SDLFramebuffer::SDLFramebuffer()
{
int rc;
LogFlow(("SDLFramebuffer::SDLFramebuffer\n"));
#if defined (RT_OS_WINDOWS)
refcnt = 0;
#endif
mScreen = NULL;
mfFullscreen = false;
mTopOffset = 0;
/* memorize the thread that inited us, that's the SDL thread */
mSdlNativeThread = RTThreadNativeSelf();
rc = RTCritSectInit(&mUpdateLock);
AssertMsg(rc == VINF_SUCCESS, ("Error from RTCritSectInit!\n"));
#ifdef VBOX_SECURELABEL
mLabelFont = NULL;
mLabelHeight = 0;
#endif
#ifdef RT_OS_LINUX
/* NOTE: we still want Ctrl-C to work, so we undo the SDL redirections */
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
#endif
/*
* Start with standard screen dimensions.
*/
mWidth = 640;
mHeight = 480;
resize();
Assert(mScreen);
}
static int pdmacFileInitialize(PPDMASYNCCOMPLETIONEPCLASS pClassGlobals, PCFGMNODE pCfgNode)
{
PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pClassGlobals;
RTFILEAIOLIMITS AioLimits; /** < Async I/O limitations. */
int rc = RTFileAioGetLimits(&AioLimits);
#ifdef DEBUG
if (RT_SUCCESS(rc) && RTEnvExist("VBOX_ASYNC_IO_FAILBACK"))
rc = VERR_ENV_VAR_NOT_FOUND;
#endif
if (RT_FAILURE(rc))
{
LogRel(("AIO: Async I/O manager not supported (rc=%Rrc). Falling back to simple manager\n",
rc));
pEpClassFile->enmMgrTypeOverride = PDMACEPFILEMGRTYPE_SIMPLE;
pEpClassFile->enmEpBackendDefault = PDMACFILEEPBACKEND_BUFFERED;
}
else
{
pEpClassFile->uBitmaskAlignment = AioLimits.cbBufferAlignment ? ~((RTR3UINTPTR)AioLimits.cbBufferAlignment - 1) : RTR3UINTPTR_MAX;
pEpClassFile->cReqsOutstandingMax = AioLimits.cReqsOutstandingMax;
if (pCfgNode)
{
/* Query the default manager type */
char *pszVal = NULL;
rc = CFGMR3QueryStringAllocDef(pCfgNode, "IoMgr", &pszVal, "Async");
AssertLogRelRCReturn(rc, rc);
rc = pdmacFileMgrTypeFromName(pszVal, &pEpClassFile->enmMgrTypeOverride);
MMR3HeapFree(pszVal);
if (RT_FAILURE(rc))
return rc;
LogRel(("AIOMgr: Default manager type is \"%s\"\n", pdmacFileMgrTypeToName(pEpClassFile->enmMgrTypeOverride)));
/* Query default backend type */
rc = CFGMR3QueryStringAllocDef(pCfgNode, "FileBackend", &pszVal, "NonBuffered");
AssertLogRelRCReturn(rc, rc);
rc = pdmacFileBackendTypeFromName(pszVal, &pEpClassFile->enmEpBackendDefault);
MMR3HeapFree(pszVal);
if (RT_FAILURE(rc))
return rc;
LogRel(("AIOMgr: Default file backend is \"%s\"\n", pdmacFileBackendTypeToName(pEpClassFile->enmEpBackendDefault)));
#ifdef RT_OS_LINUX
if ( pEpClassFile->enmMgrTypeOverride == PDMACEPFILEMGRTYPE_ASYNC
&& pEpClassFile->enmEpBackendDefault == PDMACFILEEPBACKEND_BUFFERED)
{
LogRel(("AIOMgr: Linux does not support buffered async I/O, changing to non buffered\n"));
pEpClassFile->enmEpBackendDefault = PDMACFILEEPBACKEND_NON_BUFFERED;
}
#endif
}
else
{
/* No configuration supplied, set defaults */
pEpClassFile->enmEpBackendDefault = PDMACFILEEPBACKEND_NON_BUFFERED;
pEpClassFile->enmMgrTypeOverride = PDMACEPFILEMGRTYPE_ASYNC;
}
}
/* Init critical section. */
rc = RTCritSectInit(&pEpClassFile->CritSect);
#ifdef VBOX_WITH_DEBUGGER
/* Install the error injection handler. */
if (RT_SUCCESS(rc))
{
rc = DBGCRegisterCommands(&g_aCmds[0], RT_ELEMENTS(g_aCmds));
AssertRC(rc);
}
#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
rc = TMR3TimerCreateInternal(pEpClassFile->Core.pVM, TMCLOCK_REAL, pdmacR3TimerCallback, pEpClassFile, "AC Delay", &pEpClassFile->pTimer);
AssertRC(rc);
pEpClassFile->cMilliesNext = UINT64_MAX;
#endif
#endif
return rc;
}
int main(int argc, char **argv)
{
RTEXITCODE rcExit;
/*
* Init globals and such.
*/
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
g_pszProgName = RTPathFilename(argv[0]);
#ifdef DEBUG
rc = RTCritSectInit(&g_csLog);
AssertRC(rc);
#endif
#ifdef VBOXSERVICE_TOOLBOX
/*
* Run toolbox code before all other stuff since these things are simpler
* shell/file/text utility like programs that just happens to be inside
* VBoxService and shouldn't be subject to /dev/vboxguest, pid-files and
* global mutex restrictions.
*/
if (VBoxServiceToolboxMain(argc, argv, &rcExit))
return rcExit;
#endif
/*
* Connect to the kernel part before daemonizing so we can fail and
* complain if there is some kind of problem. We need to initialize the
* guest lib *before* we do the pre-init just in case one of services needs
* do to some initial stuff with it.
*/
VBoxServiceVerbose(2, "Calling VbgR3Init()\n");
rc = VbglR3Init();
if (RT_FAILURE(rc))
{
if (rc == VERR_ACCESS_DENIED)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Insufficient privileges to start %s! Please start with Administrator/root privileges!\n",
g_pszProgName);
return RTMsgErrorExit(RTEXITCODE_FAILURE, "VbglR3Init failed with rc=%Rrc\n", rc);
}
#ifdef RT_OS_WINDOWS
/*
* Check if we're the specially spawned VBoxService.exe process that
* handles page fusion. This saves an extra executable.
*/
if ( argc == 2
&& !strcmp(argv[1], "--pagefusionfork"))
return VBoxServicePageSharingInitFork();
#endif
char szLogFile[RTPATH_MAX + 128] = "";
/*
* Parse the arguments.
*
* Note! This code predates RTGetOpt, thus the manual parsing.
*/
bool fDaemonize = true;
bool fDaemonized = false;
for (int i = 1; i < argc; i++)
{
const char *psz = argv[i];
if (*psz != '-')
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown argument '%s'\n", psz);
psz++;
/* translate long argument to short */
if (*psz == '-')
{
psz++;
size_t cch = strlen(psz);
#define MATCHES(strconst) ( cch == sizeof(strconst) - 1 \
&& !memcmp(psz, strconst, sizeof(strconst) - 1) )
if (MATCHES("foreground"))
psz = "f";
else if (MATCHES("verbose"))
psz = "v";
else if (MATCHES("version"))
psz = "V";
else if (MATCHES("help"))
psz = "h";
else if (MATCHES("interval"))
psz = "i";
#ifdef RT_OS_WINDOWS
else if (MATCHES("register"))
psz = "r";
else if (MATCHES("unregister"))
psz = "u";
#endif
else if (MATCHES("logfile"))
psz = "l";
else if (MATCHES("daemonized"))
{
fDaemonized = true;
continue;
}
else
{
bool fFound = false;
if (cch > sizeof("enable-") && !memcmp(psz, "enable-", sizeof("enable-") - 1))
for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
if ((fFound = !RTStrICmp(psz + sizeof("enable-") - 1, g_aServices[j].pDesc->pszName)))
g_aServices[j].fEnabled = true;
if (cch > sizeof("disable-") && !memcmp(psz, "disable-", sizeof("disable-") - 1))
for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
if ((fFound = !RTStrICmp(psz + sizeof("disable-") - 1, g_aServices[j].pDesc->pszName)))
g_aServices[j].fEnabled = false;
if (cch > sizeof("only-") && !memcmp(psz, "only-", sizeof("only-") - 1))
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
{
g_aServices[j].fEnabled = !RTStrICmp(psz + sizeof("only-") - 1, g_aServices[j].pDesc->pszName);
if (g_aServices[j].fEnabled)
fFound = true;
}
if (!fFound)
{
rcExit = vboxServiceLazyPreInit();
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
for (unsigned j = 0; !fFound && j < RT_ELEMENTS(g_aServices); j++)
{
rc = g_aServices[j].pDesc->pfnOption(NULL, argc, argv, &i);
fFound = rc == VINF_SUCCESS;
if (fFound)
break;
if (rc != -1)
return rc;
}
}
if (!fFound)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%s'\n", argv[i]);
continue;
}
#undef MATCHES
}
/* handle the string of short options. */
do
{
switch (*psz)
{
case 'i':
rc = VBoxServiceArgUInt32(argc, argv, psz + 1, &i,
&g_DefaultInterval, 1, (UINT32_MAX / 1000) - 1);
if (rc)
return rc;
psz = NULL;
break;
case 'f':
fDaemonize = false;
break;
case 'v':
g_cVerbosity++;
break;
case 'V':
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
return RTEXITCODE_SUCCESS;
case 'h':
case '?':
return vboxServiceUsage();
#ifdef RT_OS_WINDOWS
case 'r':
return VBoxServiceWinInstall();
case 'u':
return VBoxServiceWinUninstall();
#endif
case 'l':
{
rc = VBoxServiceArgString(argc, argv, psz + 1, &i,
szLogFile, sizeof(szLogFile));
if (rc)
return rc;
psz = NULL;
break;
}
default:
{
rcExit = vboxServiceLazyPreInit();
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
bool fFound = false;
for (unsigned j = 0; j < RT_ELEMENTS(g_aServices); j++)
{
rc = g_aServices[j].pDesc->pfnOption(&psz, argc, argv, &i);
fFound = rc == VINF_SUCCESS;
if (fFound)
break;
if (rc != -1)
return rc;
}
if (!fFound)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option '%c' (%s)\n", *psz, argv[i]);
break;
}
}
} while (psz && *++psz);
}
/* Check that at least one service is enabled. */
if (vboxServiceCountEnabledServices() == 0)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "At least one service must be enabled\n");
rc = VBoxServiceLogCreate(strlen(szLogFile) ? szLogFile : NULL);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log (%s, %Rrc)",
strlen(szLogFile) ? szLogFile : "<None>", rc);
/* Call pre-init if we didn't do it already. */
rcExit = vboxServiceLazyPreInit();
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
#ifdef RT_OS_WINDOWS
/*
* Make sure only one instance of VBoxService runs at a time. Create a
* global mutex for that.
*
* Note! The \\Global\ namespace was introduced with Win2K, thus the
* version check.
* Note! If the mutex exists CreateMutex will open it and set last error to
* ERROR_ALREADY_EXISTS.
*/
OSVERSIONINFOEX OSInfoEx;
RT_ZERO(OSInfoEx);
OSInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
SetLastError(NO_ERROR);
HANDLE hMutexAppRunning;
if ( GetVersionEx((LPOSVERSIONINFO)&OSInfoEx)
&& OSInfoEx.dwPlatformId == VER_PLATFORM_WIN32_NT
&& OSInfoEx.dwMajorVersion >= 5 /* NT 5.0 a.k.a W2K */)
hMutexAppRunning = CreateMutex(NULL, FALSE, "Global\\" VBOXSERVICE_NAME);
else
hMutexAppRunning = CreateMutex(NULL, FALSE, VBOXSERVICE_NAME);
if (hMutexAppRunning == NULL)
{
DWORD dwErr = GetLastError();
if ( dwErr == ERROR_ALREADY_EXISTS
|| dwErr == ERROR_ACCESS_DENIED)
{
VBoxServiceError("%s is already running! Terminating.", g_pszProgName);
return RTEXITCODE_FAILURE;
}
VBoxServiceError("CreateMutex failed with last error %u! Terminating", GetLastError());
return RTEXITCODE_FAILURE;
}
#else /* !RT_OS_WINDOWS */
/** @todo Add PID file creation here? */
#endif /* !RT_OS_WINDOWS */
VBoxServiceVerbose(0, "%s r%s started. Verbose level = %d\n",
RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity);
/*
* Daemonize if requested.
*/
if (fDaemonize && !fDaemonized)
{
#ifdef RT_OS_WINDOWS
VBoxServiceVerbose(2, "Starting service dispatcher ...\n");
rcExit = VBoxServiceWinEnterCtrlDispatcher();
#else
VBoxServiceVerbose(1, "Daemonizing...\n");
rc = VbglR3Daemonize(false /* fNoChDir */, false /* fNoClose */);
if (RT_FAILURE(rc))
return VBoxServiceError("Daemon failed: %Rrc\n", rc);
/* in-child */
#endif
}
#ifdef RT_OS_WINDOWS
else
#endif
{
/*
* Windows: We're running the service as a console application now. Start the
* services, enter the main thread's run loop and stop them again
* when it returns.
*
* POSIX: This is used for both daemons and console runs. Start all services
* and return immediately.
*/
#ifdef RT_OS_WINDOWS
# ifndef RT_OS_NT4
/* Install console control handler. */
if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)VBoxServiceConsoleControlHandler, TRUE /* Add handler */))
{
VBoxServiceError("Unable to add console control handler, error=%ld\n", GetLastError());
/* Just skip this error, not critical. */
}
# endif /* !RT_OS_NT4 */
#endif /* RT_OS_WINDOWS */
rc = VBoxServiceStartServices();
rcExit = RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
if (RT_SUCCESS(rc))
VBoxServiceMainWait();
#ifdef RT_OS_WINDOWS
# ifndef RT_OS_NT4
/* Uninstall console control handler. */
if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
{
VBoxServiceError("Unable to remove console control handler, error=%ld\n", GetLastError());
/* Just skip this error, not critical. */
}
# endif /* !RT_OS_NT4 */
#else /* !RT_OS_WINDOWS */
/* On Windows - since we're running as a console application - we already stopped all services
* through the console control handler. So only do the stopping of services here on other platforms
* where the break/shutdown/whatever signal was just received. */
VBoxServiceStopServices();
#endif /* RT_OS_WINDOWS */
}
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Terminated);
#ifdef RT_OS_WINDOWS
/*
* Cleanup mutex.
*/
CloseHandle(hMutexAppRunning);
#endif
VBoxServiceVerbose(0, "Ended.\n");
#ifdef DEBUG
RTCritSectDelete(&g_csLog);
//RTMemTrackerDumpAllToStdOut();
#endif
VBoxServiceLogDestroy();
return rcExit;
}
/**
* Initialize the network shaper.
*
* @returns VBox status code
* @param pVM Pointer to the VM.
*/
int pdmR3NetShaperInit(PVM pVM)
{
LogFlowFunc((": pVM=%p\n", pVM));
VM_ASSERT_EMT(pVM);
PPDMNETSHAPER pNetShaper = NULL;
int rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_NET_SHAPER,
sizeof(PDMNETSHAPER),
(void **)&pNetShaper);
if (RT_SUCCESS(rc))
{
PCFGMNODE pCfgRoot = CFGMR3GetRoot(pVM);
PCFGMNODE pCfgNetShaper = CFGMR3GetChild(CFGMR3GetChild(pCfgRoot, "PDM"), "NetworkShaper");
pNetShaper->pVM = pVM;
rc = RTCritSectInit(&pNetShaper->cs);
if (RT_SUCCESS(rc))
{
/* Create all bandwidth groups. */
PCFGMNODE pCfgBwGrp = CFGMR3GetChild(pCfgNetShaper, "BwGroups");
if (pCfgBwGrp)
{
for (PCFGMNODE pCur = CFGMR3GetFirstChild(pCfgBwGrp); pCur; pCur = CFGMR3GetNextChild(pCur))
{
uint64_t cbMax;
size_t cbName = CFGMR3GetNameLen(pCur) + 1;
char *pszBwGrpId = (char *)RTMemAllocZ(cbName);
if (!pszBwGrpId)
{
rc = VERR_NO_MEMORY;
break;
}
rc = CFGMR3GetName(pCur, pszBwGrpId, cbName);
AssertRC(rc);
if (RT_SUCCESS(rc))
rc = CFGMR3QueryU64(pCur, "Max", &cbMax);
if (RT_SUCCESS(rc))
rc = pdmNsBwGroupCreate(pNetShaper, pszBwGrpId, cbMax);
RTMemFree(pszBwGrpId);
if (RT_FAILURE(rc))
break;
}
}
if (RT_SUCCESS(rc))
{
PUVM pUVM = pVM->pUVM;
AssertMsg(!pUVM->pdm.s.pNetShaper, ("Network shaper was already initialized\n"));
char szDesc[64];
static unsigned s_iThread;
RTStrPrintf(szDesc, sizeof(szDesc), "PDMNsTx-%d", ++s_iThread);
rc = PDMR3ThreadCreate(pVM, &pNetShaper->hTxThread, pNetShaper,
pdmR3NsTxThread, pdmR3NsTxWakeUp, 0,
RTTHREADTYPE_IO, szDesc);
if (RT_SUCCESS(rc))
{
pUVM->pdm.s.pNetShaper = pNetShaper;
return VINF_SUCCESS;
}
}
RTCritSectDelete(&pNetShaper->cs);
}
MMR3HeapFree(pNetShaper);
}
LogFlowFunc((": pVM=%p rc=%Rrc\n", pVM, rc));
return rc;
}
/**
* Initialize the network shaper.
*
* @returns VBox status code
* @param pVM The cross context VM structure.
*/
int pdmR3NetShaperInit(PVM pVM)
{
LogFlow(("pdmR3NetShaperInit: pVM=%p\n", pVM));
VM_ASSERT_EMT(pVM);
PUVM pUVM = pVM->pUVM;
AssertMsgReturn(!pUVM->pdm.s.pNetShaper, ("Network shaper was already initialized\n"), VERR_WRONG_ORDER);
PPDMNETSHAPER pShaper;
int rc = MMR3HeapAllocZEx(pVM, MM_TAG_PDM_NET_SHAPER, sizeof(PDMNETSHAPER), (void **)&pShaper);
if (RT_SUCCESS(rc))
{
PCFGMNODE pCfgNetShaper = CFGMR3GetChild(CFGMR3GetChild(CFGMR3GetRoot(pVM), "PDM"), "NetworkShaper");
pShaper->pVM = pVM;
rc = RTCritSectInit(&pShaper->Lock);
if (RT_SUCCESS(rc))
{
/* Create all bandwidth groups. */
PCFGMNODE pCfgBwGrp = CFGMR3GetChild(pCfgNetShaper, "BwGroups");
if (pCfgBwGrp)
{
for (PCFGMNODE pCur = CFGMR3GetFirstChild(pCfgBwGrp); pCur; pCur = CFGMR3GetNextChild(pCur))
{
size_t cbName = CFGMR3GetNameLen(pCur) + 1;
char *pszBwGrpId = (char *)RTMemAllocZ(cbName);
if (pszBwGrpId)
{
rc = CFGMR3GetName(pCur, pszBwGrpId, cbName);
if (RT_SUCCESS(rc))
{
uint64_t cbMax;
rc = CFGMR3QueryU64(pCur, "Max", &cbMax);
if (RT_SUCCESS(rc))
rc = pdmNsBwGroupCreate(pShaper, pszBwGrpId, cbMax);
}
RTMemFree(pszBwGrpId);
}
else
rc = VERR_NO_MEMORY;
if (RT_FAILURE(rc))
break;
}
}
if (RT_SUCCESS(rc))
{
rc = PDMR3ThreadCreate(pVM, &pShaper->pTxThread, pShaper, pdmR3NsTxThread, pdmR3NsTxWakeUp,
0 /*cbStack*/, RTTHREADTYPE_IO, "PDMNsTx");
if (RT_SUCCESS(rc))
{
pUVM->pdm.s.pNetShaper = pShaper;
return VINF_SUCCESS;
}
}
RTCritSectDelete(&pShaper->Lock);
}
MMR3HeapFree(pShaper);
}
LogFlow(("pdmR3NetShaperInit: pVM=%p rc=%Rrc\n", pVM, rc));
return rc;
}
HRESULT HostDnsService::init (void)
{
int rc = RTCritSectInit(&m_hCritSect);
AssertRCReturn(rc, E_FAIL);
return S_OK;
}
/**
* Open a USB device and create a backend instance for it.
*
* @returns VBox status code.
*/
static DECLCALLBACK(int) usbProxyWinOpen(PUSBPROXYDEV pProxyDev, const char *pszAddress, void *pvBackend)
{
PPRIV_USBW32 pPriv = USBPROXYDEV_2_DATA(pProxyDev, PPRIV_USBW32);
int rc = VINF_SUCCESS;
pPriv->cAllocatedUrbs = 32;
pPriv->paHandles = (PHANDLE)RTMemAllocZ(sizeof(pPriv->paHandles[0]) * pPriv->cAllocatedUrbs);
pPriv->paQueuedUrbs = (PQUEUED_URB *)RTMemAllocZ(sizeof(pPriv->paQueuedUrbs[0]) * pPriv->cAllocatedUrbs);
if ( pPriv->paQueuedUrbs
&& pPriv->paHandles)
{
/*
* Open the device.
*/
pPriv->hDev = CreateFile(pszAddress,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL, // no SECURITY_ATTRIBUTES structure
OPEN_EXISTING, // No special create flags
FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, // overlapped IO
NULL); // No template file
if (pPriv->hDev != INVALID_HANDLE_VALUE)
{
Log(("usbProxyWinOpen: hDev=%p\n", pPriv->hDev));
/*
* Check the version
*/
USBSUP_VERSION version = {0};
DWORD cbReturned = 0;
if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_GET_VERSION, NULL, 0, &version, sizeof(version), &cbReturned, NULL))
{
if (!( version.u32Major != USBDRV_MAJOR_VERSION
|| version.u32Minor < USBDRV_MINOR_VERSION))
{
USBSUP_CLAIMDEV in;
in.bInterfaceNumber = 0;
cbReturned = 0;
if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_CLAIM_DEVICE, &in, sizeof(in), &in, sizeof(in), &cbReturned, NULL))
{
if (in.fClaimed)
{
pPriv->fClaimed = true;
#if 0 /** @todo this needs to be enabled if windows chooses a default config. Test with the TrekStor GO Stick. */
pProxyDev->iActiveCfg = 1;
pProxyDev->cIgnoreSetConfigs = 1;
#endif
rc = RTCritSectInit(&pPriv->CritSect);
AssertRC(rc);
pPriv->hEventWakeup = CreateEvent(NULL, FALSE, FALSE, NULL);
Assert(pPriv->hEventWakeup);
pPriv->paHandles[0] = pPriv->hEventWakeup;
return VINF_SUCCESS;
}
rc = VERR_GENERAL_FAILURE;
Log(("usbproxy: unable to claim device %x (%s)!!\n", pPriv->hDev, pszAddress));
}
}
else
{
rc = VERR_VERSION_MISMATCH;
Log(("usbproxy: Version mismatch: %d.%d != %d.%d (cur)\n",
version.u32Major, version.u32Minor, USBDRV_MAJOR_VERSION, USBDRV_MINOR_VERSION));
}
}
/* Convert last error if necessary */
if (RT_SUCCESS(rc))
{
DWORD dwErr = GetLastError();
Log(("usbproxy: last error %d\n", dwErr));
rc = RTErrConvertFromWin32(dwErr);
}
CloseHandle(pPriv->hDev);
pPriv->hDev = INVALID_HANDLE_VALUE;
}
else
{
Log(("usbproxy: FAILED to open '%s'! last error %d\n", pszAddress, GetLastError()));
rc = VERR_FILE_NOT_FOUND;
}
}
else
rc = VERR_NO_MEMORY;
RTMemFree(pPriv->paQueuedUrbs);
RTMemFree(pPriv->paHandles);
return rc;
}
RTDECL(int) RTMemCacheCreate(PRTMEMCACHE phMemCache, size_t cbObject, size_t cbAlignment, uint32_t cMaxObjects,
PFNMEMCACHECTOR pfnCtor, PFNMEMCACHEDTOR pfnDtor, void *pvUser, uint32_t fFlags)
{
AssertPtr(phMemCache);
AssertPtrNull(pfnCtor);
AssertPtrNull(pfnDtor);
AssertReturn(!pfnDtor || pfnCtor, VERR_INVALID_PARAMETER);
AssertReturn(cbObject > 0, VERR_INVALID_PARAMETER);
AssertReturn(cbObject <= PAGE_SIZE / 8, VERR_INVALID_PARAMETER);
AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
if (cbAlignment == 0)
{
if (cbObject <= 2)
cbAlignment = cbObject;
else if (cbObject <= 4)
cbAlignment = 4;
else if (cbObject <= 8)
cbAlignment = 8;
else if (cbObject <= 16)
cbAlignment = 16;
else if (cbObject <= 32)
cbAlignment = 32;
else
cbAlignment = 64;
}
else
{
AssertReturn(!((cbAlignment - 1) & cbAlignment), VERR_NOT_POWER_OF_TWO);
AssertReturn(cbAlignment <= 64, VERR_OUT_OF_RANGE);
}
/*
* Allocate and initialize the instance memory.
*/
RTMEMCACHEINT *pThis = (RTMEMCACHEINT *)RTMemAlloc(sizeof(*pThis));
if (!pThis)
return VERR_NO_MEMORY;
int rc = RTCritSectInit(&pThis->CritSect);
if (RT_FAILURE(rc))
{
RTMemFree(pThis);
return rc;
}
pThis->u32Magic = RTMEMCACHE_MAGIC;
pThis->cbObject = (uint32_t)RT_ALIGN_Z(cbObject, cbAlignment);
pThis->cbAlignment = (uint32_t)cbAlignment;
pThis->cPerPage = (uint32_t)((PAGE_SIZE - RT_ALIGN_Z(sizeof(RTMEMCACHEPAGE), cbAlignment)) / pThis->cbObject);
while ( RT_ALIGN_Z(sizeof(RTMEMCACHEPAGE), 8)
+ pThis->cPerPage * pThis->cbObject
+ RT_ALIGN(pThis->cPerPage, 64) / 8 * 2
> PAGE_SIZE)
pThis->cPerPage--;
pThis->cBits = RT_ALIGN(pThis->cPerPage, 64);
pThis->cMax = cMaxObjects;
pThis->fUseFreeList = cbObject >= sizeof(RTMEMCACHEFREEOBJ)
&& !pfnCtor
&& !pfnDtor;
pThis->pPageHead = NULL;
pThis->ppPageNext = &pThis->pPageHead;
pThis->pfnCtor = pfnCtor;
pThis->pfnDtor = pfnDtor;
pThis->pvUser = pvUser;
pThis->cTotal = 0;
pThis->cFree = 0;
pThis->pPageHint = NULL;
pThis->pFreeTop = NULL;
*phMemCache = pThis;
return VINF_SUCCESS;
}
RTDECL(int) RTDbgModCreateFromMap(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTUINTPTR uSubtrahend, uint32_t fFlags)
{
/*
* Input validation and lazy initialization.
*/
AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
*phDbgMod = NIL_RTDBGMOD;
AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER);
int rc = rtDbgModLazyInit();
if (RT_FAILURE(rc))
return rc;
if (!pszName)
pszName = RTPathFilename(pszFilename);
/*
* Allocate a new module instance.
*/
PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
if (!pDbgMod)
return VERR_NO_MEMORY;
pDbgMod->u32Magic = RTDBGMOD_MAGIC;
pDbgMod->cRefs = 1;
rc = RTCritSectInit(&pDbgMod->CritSect);
if (RT_SUCCESS(rc))
{
pDbgMod->pszName = RTStrCacheEnter(g_hDbgModStrCache, pszName);
if (pDbgMod->pszName)
{
pDbgMod->pszDbgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
if (pDbgMod->pszDbgFile)
{
/*
* Try the map file readers.
*/
rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
if (RT_SUCCESS(rc))
{
rc = VERR_DBG_NO_MATCHING_INTERPRETER;
for (PRTDBGMODREGDBG pCur = g_pDbgHead; pCur; pCur = pCur->pNext)
{
if (pCur->pVt->fSupports & RT_DBGTYPE_MAP)
{
pDbgMod->pDbgVt = pCur->pVt;
pDbgMod->pvDbgPriv = NULL;
rc = pCur->pVt->pfnTryOpen(pDbgMod);
if (RT_SUCCESS(rc))
{
ASMAtomicIncU32(&pCur->cUsers);
RTSemRWReleaseRead(g_hDbgModRWSem);
*phDbgMod = pDbgMod;
return rc;
}
}
}
/* bail out */
RTSemRWReleaseRead(g_hDbgModRWSem);
}
RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
}
RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszDbgFile);
}
RTCritSectDelete(&pDbgMod->CritSect);
}
RTMemFree(pDbgMod);
return rc;
}
RTDECL(int) RTLocalIpcSessionConnect(PRTLOCALIPCSESSION phSession, const char *pszName, uint32_t fFlags)
{
AssertPtrReturn(phSession, VERR_INVALID_POINTER);
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertReturn(*pszName, VERR_INVALID_PARAMETER);
AssertReturn(!fFlags, VERR_INVALID_PARAMETER); /* Flags currently unused, must be 0. */
PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)RTMemAlloc(sizeof(*pThis));
if (!pThis)
return VERR_NO_MEMORY;
pThis->u32Magic = RTLOCALIPCSESSION_MAGIC;
pThis->cRefs = 1; /* The one we return. */
pThis->fIOPending = false;
pThis->fZeroByteRead = false;
pThis->fCancelled = false;
pThis->pbBounceBuf = NULL;
pThis->cbBounceBufAlloc = 0;
pThis->cbBounceBufUsed = 0;
int rc = RTCritSectInit(&pThis->CritSect);
if (RT_SUCCESS(rc))
{
pThis->hEvent = CreateEvent(NULL /*lpEventAttributes*/, TRUE /*bManualReset*/,
FALSE /*bInitialState*/, NULL /*lpName*/);
if (pThis->hEvent != NULL)
{
RT_ZERO(pThis->OverlappedIO);
pThis->OverlappedIO.Internal = STATUS_PENDING;
pThis->OverlappedIO.hEvent = pThis->hEvent;
PSECURITY_DESCRIPTOR pSecDesc;
rc = rtLocalIpcServerWinAllocSecurityDescriptior(&pSecDesc, false /* Client */);
if (RT_SUCCESS(rc))
{
char *pszPipe;
if (RTStrAPrintf(&pszPipe, "%s%s", RTLOCALIPC_WIN_PREFIX, pszName))
{
SECURITY_ATTRIBUTES SecAttrs;
SecAttrs.nLength = sizeof(SECURITY_ATTRIBUTES);
SecAttrs.lpSecurityDescriptor = pSecDesc;
SecAttrs.bInheritHandle = FALSE;
HANDLE hPipe = CreateFile(pszPipe, /* pipe name */
GENERIC_READ /* read and write access */
| GENERIC_WRITE,
0, /* no sharing */
&SecAttrs, /* lpSecurityAttributes */
OPEN_EXISTING, /* opens existing pipe */
FILE_FLAG_OVERLAPPED, /* default attributes */
NULL); /* no template file */
RTStrFree(pszPipe);
if (hPipe != INVALID_HANDLE_VALUE)
{
LocalFree(pSecDesc);
pThis->hNmPipe = hPipe;
*phSession = pThis;
return VINF_SUCCESS;
}
else
rc = RTErrConvertFromWin32(GetLastError());
}
else
rc = VERR_NO_MEMORY;
LocalFree(pSecDesc);
}
BOOL fRc = CloseHandle(pThis->hEvent);
AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
}
else
rc = RTErrConvertFromWin32(GetLastError());
int rc2 = RTCritSectDelete(&pThis->CritSect);
AssertRC(rc2);
}
RTMemFree(pThis);
return rc;
}
