VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-haiku-stubs.c@ 85271

Last change on this file since 85271 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.8 KB
Line 
1/* $Id: VBoxGuest-haiku-stubs.c 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * VBoxGuest kernel module, Haiku Guest Additions, stubs.
4 */
5
6/*
7 * Copyright (C) 2012-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27/*
28 * This code is based on:
29 *
30 * VirtualBox Guest Additions for Haiku.
31 * Copyright (c) 2011 Mike Smith <mike@scgtrp.net>
32 * François Revol <revol@free.fr>
33 *
34 * Permission is hereby granted, free of charge, to any person
35 * obtaining a copy of this software and associated documentation
36 * files (the "Software"), to deal in the Software without
37 * restriction, including without limitation the rights to use,
38 * copy, modify, merge, publish, distribute, sublicense, and/or sell
39 * copies of the Software, and to permit persons to whom the
40 * Software is furnished to do so, subject to the following
41 * conditions:
42 *
43 * The above copyright notice and this permission notice shall be
44 * included in all copies or substantial portions of the Software.
45 *
46 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
47 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
48 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
49 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
50 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
51 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
52 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
53 * OTHER DEALINGS IN THE SOFTWARE.
54 */
55
56
57/*
58 * This file provides stubs for calling VBox runtime functions through the vboxguest module.
59 * It should be linked into any driver or module that uses the VBox runtime, except vboxguest
60 * itself (which contains the actual library and therefore doesn't need stubs to call it).
61 */
62
63#include "VBoxGuest-haiku.h"
64#include "VBoxGuestInternal.h"
65#include <VBox/log.h>
66#include <iprt/assert.h>
67#include <iprt/initterm.h>
68#include <iprt/process.h>
69#include <iprt/mem.h>
70#include <iprt/asm.h>
71#include <iprt/mp.h>
72#include <iprt/power.h>
73#include <iprt/thread.h>
74
75// >>> file('/tmp/stubs.c', 'w').writelines([re.sub(r'^(?P<returntype>[^(]+) \(\*_(?P<functionname>[A-Za-z0-9_]+)\)\((?P<params>[^)]+)\);', lambda m: '%s %s(%s)\n{\n %sg_VBoxGuest->_%s(%s);\n}\n' % (m.group(1), m.group(2), m.group(3), ('return ' if m.group(1) != 'void' else ''), m.group(2), (', '.join(a.split(' ')[-1].replace('*', '') for a in m.group(3).split(',')) if m.group(3) != 'void' else '')), f) for f in functions])
76
77struct vboxguest_module_info *g_VBoxGuest;
78
79RTDECL(size_t) RTLogBackdoorPrintf(const char *pszFormat, ...)
80{
81 va_list args;
82 size_t cb;
83
84 va_start(args, pszFormat);
85 cb = g_VBoxGuest->_RTLogBackdoorPrintf(pszFormat, args);
86 va_end(args);
87
88 return cb;
89}
90RTDECL(size_t) RTLogBackdoorPrintfV(const char *pszFormat, va_list args)
91{
92 return g_VBoxGuest->_RTLogBackdoorPrintfV(pszFormat, args);
93}
94RTDECL(int) RTLogSetDefaultInstanceThread(PRTLOGGER pLogger, uintptr_t uKey)
95{
96 return g_VBoxGuest->_RTLogSetDefaultInstanceThread(pLogger, uKey);
97}
98RTDECL(int) RTMemAllocExTag(size_t cb, size_t cbAlignment, uint32_t fFlags, const char *pszTag, void **ppv)
99{
100 return g_VBoxGuest->_RTMemAllocExTag(cb, cbAlignment, fFlags, pszTag, ppv);
101}
102RTR0DECL(void*) RTMemContAlloc(PRTCCPHYS pPhys, size_t cb)
103{
104 return g_VBoxGuest->_RTMemContAlloc(pPhys, cb);
105}
106RTR0DECL(void) RTMemContFree(void *pv, size_t cb)
107{
108 g_VBoxGuest->_RTMemContFree(pv, cb);
109}
110RTDECL(void) RTMemFreeEx(void *pv, size_t cb)
111{
112 g_VBoxGuest->_RTMemFreeEx(pv, cb);
113}
114RTDECL(bool) RTMpIsCpuPossible(RTCPUID idCpu)
115{
116 return g_VBoxGuest->_RTMpIsCpuPossible(idCpu);
117}
118RTDECL(int) RTMpNotificationDeregister(PFNRTMPNOTIFICATION pfnCallback, void *pvUser)
119{
120 return g_VBoxGuest->_RTMpNotificationDeregister(pfnCallback, pvUser);
121}
122RTDECL(int) RTMpNotificationRegister(PFNRTMPNOTIFICATION pfnCallback, void *pvUser)
123{
124 return g_VBoxGuest->_RTMpNotificationRegister(pfnCallback, pvUser);
125}
126RTDECL(int) RTMpOnAll(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
127{
128 return g_VBoxGuest->_RTMpOnAll(pfnWorker, pvUser1, pvUser2);
129}
130RTDECL(int) RTMpOnOthers(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
131{
132 return g_VBoxGuest->_RTMpOnOthers(pfnWorker, pvUser1, pvUser2);
133}
134RTDECL(int) RTMpOnSpecific(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
135{
136 return g_VBoxGuest->_RTMpOnSpecific(idCpu, pfnWorker, pvUser1, pvUser2);
137}
138RTDECL(int) RTPowerNotificationDeregister(PFNRTPOWERNOTIFICATION pfnCallback, void *pvUser)
139{
140 return g_VBoxGuest->_RTPowerNotificationDeregister(pfnCallback, pvUser);
141}
142RTDECL(int) RTPowerNotificationRegister(PFNRTPOWERNOTIFICATION pfnCallback, void *pvUser)
143{
144 return g_VBoxGuest->_RTPowerNotificationRegister(pfnCallback, pvUser);
145}
146RTDECL(int) RTPowerSignalEvent(RTPOWEREVENT enmEvent)
147{
148 return g_VBoxGuest->_RTPowerSignalEvent(enmEvent);
149}
150RTR0DECL(void) RTR0AssertPanicSystem(void)
151{
152 g_VBoxGuest->_RTR0AssertPanicSystem();
153}
154RTR0DECL(int) RTR0Init(unsigned fReserved)
155{
156 return g_VBoxGuest->_RTR0Init(fReserved);
157}
158RTR0DECL(void*) RTR0MemObjAddress(RTR0MEMOBJ MemObj)
159{
160 return g_VBoxGuest->_RTR0MemObjAddress(MemObj);
161}
162RTR0DECL(RTR3PTR) RTR0MemObjAddressR3(RTR0MEMOBJ MemObj)
163{
164 return g_VBoxGuest->_RTR0MemObjAddressR3(MemObj);
165}
166RTR0DECL(int) RTR0MemObjAllocContTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
167{
168 return g_VBoxGuest->_RTR0MemObjAllocContTag(pMemObj, cb, fExecutable, pszTag);
169}
170RTR0DECL(int) RTR0MemObjAllocLowTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
171{
172 return g_VBoxGuest->_RTR0MemObjAllocLowTag(pMemObj, cb, fExecutable, pszTag);
173}
174RTR0DECL(int) RTR0MemObjAllocPageTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
175{
176 return g_VBoxGuest->_RTR0MemObjAllocPageTag(pMemObj, cb, fExecutable, pszTag);
177}
178RTR0DECL(int) RTR0MemObjAllocPhysExTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, size_t uAlignment, const char *pszTag)
179{
180 return g_VBoxGuest->_RTR0MemObjAllocPhysExTag(pMemObj, cb, PhysHighest, uAlignment, pszTag);
181}
182RTR0DECL(int) RTR0MemObjAllocPhysNCTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
183{
184 return g_VBoxGuest->_RTR0MemObjAllocPhysNCTag(pMemObj, cb, PhysHighest, pszTag);
185}
186RTR0DECL(int) RTR0MemObjAllocPhysTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
187{
188 return g_VBoxGuest->_RTR0MemObjAllocPhysTag(pMemObj, cb, PhysHighest, pszTag);
189}
190RTR0DECL(int) RTR0MemObjEnterPhysTag(PRTR0MEMOBJ pMemObj, RTHCPHYS Phys, size_t cb, uint32_t uCachePolicy, const char *pszTag)
191{
192 return g_VBoxGuest->_RTR0MemObjEnterPhysTag(pMemObj, Phys, cb, uCachePolicy, pszTag);
193}
194RTR0DECL(int) RTR0MemObjFree(RTR0MEMOBJ MemObj, bool fFreeMappings)
195{
196 return g_VBoxGuest->_RTR0MemObjFree(MemObj, fFreeMappings);
197}
198RTR0DECL(RTHCPHYS) RTR0MemObjGetPagePhysAddr(RTR0MEMOBJ MemObj, size_t iPage)
199{
200 return g_VBoxGuest->_RTR0MemObjGetPagePhysAddr(MemObj, iPage);
201}
202RTR0DECL(bool) RTR0MemObjIsMapping(RTR0MEMOBJ MemObj)
203{
204 return g_VBoxGuest->_RTR0MemObjIsMapping(MemObj);
205}
206RTR0DECL(int) RTR0MemObjLockKernelTag(PRTR0MEMOBJ pMemObj, void *pv, size_t cb, uint32_t fAccess, const char *pszTag)
207{
208 return g_VBoxGuest->_RTR0MemObjLockKernelTag(pMemObj, pv, cb, fAccess, pszTag);
209}
210RTR0DECL(int) RTR0MemObjLockUserTag(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process, const char *pszTag)
211{
212 return g_VBoxGuest->_RTR0MemObjLockUserTag(pMemObj, R3Ptr, cb, fAccess, R0Process, pszTag);
213}
214RTR0DECL(int) RTR0MemObjMapKernelExTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt, size_t offSub, size_t cbSub, const char *pszTag)
215{
216 return g_VBoxGuest->_RTR0MemObjMapKernelExTag(pMemObj, MemObjToMap, pvFixed, uAlignment, fProt, offSub, cbSub, pszTag);
217}
218RTR0DECL(int) RTR0MemObjMapKernelTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment, unsigned fProt, const char *pszTag)
219{
220 return g_VBoxGuest->_RTR0MemObjMapKernelTag(pMemObj, MemObjToMap, pvFixed, uAlignment, fProt, pszTag);
221}
222RTR0DECL(int) RTR0MemObjMapUserTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process, const char *pszTag)
223{
224 return g_VBoxGuest->_RTR0MemObjMapUserTag(pMemObj, MemObjToMap, R3PtrFixed, uAlignment, fProt, R0Process, pszTag);
225}
226RTR0DECL(int) RTR0MemObjProtect(RTR0MEMOBJ hMemObj, size_t offSub, size_t cbSub, uint32_t fProt)
227{
228 return g_VBoxGuest->_RTR0MemObjProtect(hMemObj, offSub, cbSub, fProt);
229}
230RTR0DECL(int) RTR0MemObjReserveKernelTag(PRTR0MEMOBJ pMemObj, void *pvFixed, size_t cb, size_t uAlignment, const char *pszTag)
231{
232 return g_VBoxGuest->_RTR0MemObjReserveKernelTag(pMemObj, pvFixed, cb, uAlignment, pszTag);
233}
234RTR0DECL(int) RTR0MemObjReserveUserTag(PRTR0MEMOBJ pMemObj, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, RTR0PROCESS R0Process, const char *pszTag)
235{
236 return g_VBoxGuest->_RTR0MemObjReserveUserTag(pMemObj, R3PtrFixed, cb, uAlignment, R0Process, pszTag);
237}
238RTR0DECL(size_t) RTR0MemObjSize(RTR0MEMOBJ MemObj)
239{
240 return g_VBoxGuest->_RTR0MemObjSize(MemObj);
241}
242RTR0DECL(RTR0PROCESS) RTR0ProcHandleSelf(void)
243{
244 return g_VBoxGuest->_RTR0ProcHandleSelf();
245}
246RTR0DECL(void) RTR0Term(void)
247{
248 g_VBoxGuest->_RTR0Term();
249}
250RTR0DECL(void) RTR0TermForced(void)
251{
252 g_VBoxGuest->_RTR0TermForced();
253}
254RTDECL(RTPROCESS) RTProcSelf(void)
255{
256 return g_VBoxGuest->_RTProcSelf();
257}
258RTDECL(uint32_t) RTSemEventGetResolution(void)
259{
260 return g_VBoxGuest->_RTSemEventGetResolution();
261}
262RTDECL(uint32_t) RTSemEventMultiGetResolution(void)
263{
264 return g_VBoxGuest->_RTSemEventMultiGetResolution();
265}
266RTDECL(int) RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout)
267{
268 return g_VBoxGuest->_RTSemEventMultiWaitEx(hEventMultiSem, fFlags, uTimeout);
269}
270RTDECL(int) RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout, RTHCUINTPTR uId, RT_SRC_POS_DECL)
271{
272 return g_VBoxGuest->_RTSemEventMultiWaitExDebug(hEventMultiSem, fFlags, uTimeout, uId, pszFile, iLine, pszFunction);
273}
274RTDECL(int) RTSemEventWaitEx(RTSEMEVENT hEventSem, uint32_t fFlags, uint64_t uTimeout)
275{
276 return g_VBoxGuest->_RTSemEventWaitEx(hEventSem, fFlags, uTimeout);
277}
278RTDECL(int) RTSemEventWaitExDebug(RTSEMEVENT hEventSem, uint32_t fFlags, uint64_t uTimeout, RTHCUINTPTR uId, RT_SRC_POS_DECL)
279{
280 return g_VBoxGuest->_RTSemEventWaitExDebug(hEventSem, fFlags, uTimeout, uId, pszFile, iLine, pszFunction);
281}
282RTDECL(bool) RTThreadIsInInterrupt(RTTHREAD hThread)
283{
284 return g_VBoxGuest->_RTThreadIsInInterrupt(hThread);
285}
286RTDECL(void) RTThreadPreemptDisable(PRTTHREADPREEMPTSTATE pState)
287{
288 g_VBoxGuest->_RTThreadPreemptDisable(pState);
289}
290RTDECL(bool) RTThreadPreemptIsEnabled(RTTHREAD hThread)
291{
292 return g_VBoxGuest->_RTThreadPreemptIsEnabled(hThread);
293}
294RTDECL(bool) RTThreadPreemptIsPending(RTTHREAD hThread)
295{
296 return g_VBoxGuest->_RTThreadPreemptIsPending(hThread);
297}
298RTDECL(bool) RTThreadPreemptIsPendingTrusty(void)
299{
300 return g_VBoxGuest->_RTThreadPreemptIsPendingTrusty();
301}
302RTDECL(bool) RTThreadPreemptIsPossible(void)
303{
304 return g_VBoxGuest->_RTThreadPreemptIsPossible();
305}
306RTDECL(void) RTThreadPreemptRestore(PRTTHREADPREEMPTSTATE pState)
307{
308 g_VBoxGuest->_RTThreadPreemptRestore(pState);
309}
310RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
311{
312 return g_VBoxGuest->_RTTimerGetSystemGranularity();
313}
314RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
315{
316 return g_VBoxGuest->_RTTimerReleaseSystemGranularity(u32Granted);
317}
318RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
319{
320 return g_VBoxGuest->_RTTimerRequestSystemGranularity(u32Request, pu32Granted);
321}
322RTDECL(void) RTSpinlockAcquire(RTSPINLOCK Spinlock)
323{
324 g_VBoxGuest->_RTSpinlockAcquire(Spinlock);
325}
326RTDECL(void) RTSpinlockRelease(RTSPINLOCK Spinlock)
327{
328 g_VBoxGuest->_RTSpinlockRelease(Spinlock);
329}
330RTDECL(void*) RTMemTmpAllocTag(size_t cb, const char *pszTag)
331{
332 return g_VBoxGuest->_RTMemTmpAllocTag(cb, pszTag);
333}
334RTDECL(void) RTMemTmpFree(void *pv)
335{
336 g_VBoxGuest->_RTMemTmpFree(pv);
337}
338RTDECL(PRTLOGGER) RTLogDefaultInstance(void)
339{
340 return g_VBoxGuest->_RTLogDefaultInstance();
341}
342RTDECL(PRTLOGGER) RTLogDefaultInstanceEx(uint32_t fFlagsAndGroup)
343{
344 return g_VBoxGuest->_RTLogDefaultInstanceEx(fFlagsAndGroup);
345}
346RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(void)
347{
348 return g_VBoxGuest->_RTLogRelGetDefaultInstance();
349}
350RTDECL(PRTLOGGER) RTLogRelGetDefaultInstance(uint32_t fFlags, uint32_t iGroup)
351{
352 return g_VBoxGuest->_RTLogRelGetDefaultInstanceEx(fFlags, iGroup);
353}
354RTDECL(int) RTErrConvertToErrno(int iErr)
355{
356 return g_VBoxGuest->_RTErrConvertToErrno(iErr);
357}
358int VGDrvCommonIoCtl(unsigned iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, void *pvData, size_t cbData, size_t *pcbDataReturned)
359{
360 return g_VBoxGuest->_VGDrvCommonIoCtl(iFunction, pDevExt, pSession, pvData, cbData, pcbDataReturned);
361}
362int VGDrvCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, uint32_t fRequestor, PVBOXGUESTSESSION *ppSession)
363{
364 return g_VBoxGuest->_VGDrvCommonCreateUserSession(pDevExt, fRequestor, ppSession);
365}
366void VGDrvCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
367{
368 g_VBoxGuest->_VGDrvCommonCloseSession(pDevExt, pSession);
369}
370void* VBoxGuestIDCOpen(uint32_t *pu32Version)
371{
372 return g_VBoxGuest->_VBoxGuestIDCOpen(pu32Version);
373}
374int VBoxGuestIDCClose(void *pvSession)
375{
376 return g_VBoxGuest->_VBoxGuestIDCClose(pvSession);
377}
378int VBoxGuestIDCCall(void *pvSession, unsigned iCmd, void *pvData, size_t cbData, size_t *pcbDataReturned)
379{
380 return g_VBoxGuest->_VBoxGuestIDCCall(pvSession, iCmd, pvData, cbData, pcbDataReturned);
381}
382RTDECL(void) RTAssertMsg1Weak(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)
383{
384 g_VBoxGuest->_RTAssertMsg1Weak(pszExpr, uLine, pszFile, pszFunction);
385}
386RTDECL(void) RTAssertMsg2Weak(const char *pszFormat, ...)
387{
388 va_list va;
389 va_start(va, pszFormat);
390 RTAssertMsg2WeakV(pszFormat, va);
391 va_end(va);
392}
393RTDECL(void) RTAssertMsg2WeakV(const char *pszFormat, va_list va)
394{
395 g_VBoxGuest->_RTAssertMsg2WeakV(pszFormat, va);
396}
397RTDECL(bool) RTAssertShouldPanic(void)
398{
399 return g_VBoxGuest->_RTAssertShouldPanic();
400}
401RTDECL(int) RTSemFastMutexCreate(PRTSEMFASTMUTEX phFastMtx)
402{
403 return g_VBoxGuest->_RTSemFastMutexCreate(phFastMtx);
404}
405RTDECL(int) RTSemFastMutexDestroy(RTSEMFASTMUTEX hFastMtx)
406{
407 return g_VBoxGuest->_RTSemFastMutexDestroy(hFastMtx);
408}
409RTDECL(int) RTSemFastMutexRelease(RTSEMFASTMUTEX hFastMtx)
410{
411 return g_VBoxGuest->_RTSemFastMutexRelease(hFastMtx);
412}
413RTDECL(int) RTSemFastMutexRequest(RTSEMFASTMUTEX hFastMtx)
414{
415 return g_VBoxGuest->_RTSemFastMutexRequest(hFastMtx);
416}
417RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX phFastMtx)
418{
419 return g_VBoxGuest->_RTSemMutexCreate(phFastMtx);
420}
421RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX hFastMtx)
422{
423 return g_VBoxGuest->_RTSemMutexDestroy(hFastMtx);
424}
425RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hFastMtx)
426{
427 return g_VBoxGuest->_RTSemMutexRelease(hFastMtx);
428}
429RTDECL(int) RTSemMutexRequest(RTSEMMUTEX hFastMtx, RTMSINTERVAL cMillies)
430{
431 return g_VBoxGuest->_RTSemMutexRequest(hFastMtx, cMillies);
432}
433int RTHeapSimpleRelocate(RTHEAPSIMPLE hHeap, uintptr_t offDelta)
434{
435 return g_VBoxGuest->_RTHeapSimpleRelocate(hHeap, offDelta);
436}
437int RTHeapOffsetInit(PRTHEAPOFFSET phHeap, void *pvMemory, size_t cbMemory)
438{
439 return g_VBoxGuest->_RTHeapOffsetInit(phHeap, pvMemory, cbMemory);
440}
441int RTHeapSimpleInit(PRTHEAPSIMPLE pHeap, void *pvMemory, size_t cbMemory)
442{
443 return g_VBoxGuest->_RTHeapSimpleInit(pHeap, pvMemory, cbMemory);
444}
445void* RTHeapOffsetAlloc(RTHEAPOFFSET hHeap, size_t cb, size_t cbAlignment)
446{
447 return g_VBoxGuest->_RTHeapOffsetAlloc(hHeap, cb, cbAlignment);
448}
449void* RTHeapSimpleAlloc(RTHEAPSIMPLE Heap, size_t cb, size_t cbAlignment)
450{
451 return g_VBoxGuest->_RTHeapSimpleAlloc(Heap, cb, cbAlignment);
452}
453void RTHeapOffsetFree(RTHEAPOFFSET hHeap, void *pv)
454{
455 g_VBoxGuest->_RTHeapOffsetFree(hHeap, pv);
456}
457void RTHeapSimpleFree(RTHEAPSIMPLE Heap, void *pv)
458{
459 g_VBoxGuest->_RTHeapSimpleFree(Heap, pv);
460}
461
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette