memobj-r0drv.cpp@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Rev Revision`
File size: 34.1 KB

Line
1	/* $Id: memobj-r0drv.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* IPRT - Ring-0 Memory Objects, Common Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP RTLOGGROUP_DEFAULT /// @todo RTLOGGROUP_MEM
42	#define RTMEM_NO_WRAP_TO_EF_APIS /* circular dependency otherwise. */
43	#include <iprt/memobj.h>
44	#include "internal/iprt.h"
45
46	#include <iprt/alloc.h>
47	#include <iprt/asm.h>
48	#include <iprt/assert.h>
49	#include <iprt/err.h>
50	#include <iprt/log.h>
51	#include <iprt/mp.h>
52	#include <iprt/param.h>
53	#include <iprt/process.h>
54	#include <iprt/thread.h>
55
56	#include "internal/memobj.h"
57
58
59	/**
60	* Internal function for allocating a new memory object.
61	*
62	* @returns The allocated and initialized handle.
63	* @param cbSelf The size of the memory object handle. 0 mean default size.
64	* @param enmType The memory object type.
65	* @param pv The memory object mapping.
66	* @param cb The size of the memory object.
67	* @param pszTag The tag string.
68	*/
69	DECLHIDDEN(PRTR0MEMOBJINTERNAL) rtR0MemObjNew(size_t cbSelf, RTR0MEMOBJTYPE enmType, void pv, size_t cb, const char pszTag)
70	{
71	PRTR0MEMOBJINTERNAL pNew;
72
73	/* validate the size */
74	if (!cbSelf)
75	cbSelf = sizeof(*pNew);
76	Assert(cbSelf >= sizeof(*pNew));
77	Assert(cbSelf == (uint32_t)cbSelf);
78	AssertMsg(RT_ALIGN_Z(cb, PAGE_SIZE) == cb, ("%#zx\n", cb));
79
80	/*
81	* Allocate and initialize the object.
82	*/
83	pNew = (PRTR0MEMOBJINTERNAL)RTMemAllocZ(cbSelf);
84	if (pNew)
85	{
86	pNew->u32Magic = RTR0MEMOBJ_MAGIC;
87	pNew->cbSelf = (uint32_t)cbSelf;
88	pNew->enmType = enmType;
89	pNew->fFlags = 0;
90	pNew->cb = cb;
91	pNew->pv = pv;
92	#ifdef DEBUG
93	pNew->pszTag = pszTag;
94	#else
95	RT_NOREF_PV(pszTag);
96	#endif
97	}
98	return pNew;
99	}
100
101
102	/**
103	* Deletes an incomplete memory object.
104	*
105	* This is for cleaning up after failures during object creation.
106	*
107	* @param pMem The incomplete memory object to delete.
108	*/
109	DECLHIDDEN(void) rtR0MemObjDelete(PRTR0MEMOBJINTERNAL pMem)
110	{
111	if (pMem)
112	{
113	ASMAtomicUoWriteU32(&pMem->u32Magic, ~RTR0MEMOBJ_MAGIC);
114	pMem->enmType = RTR0MEMOBJTYPE_END;
115	RTMemFree(pMem);
116	}
117	}
118
119
120	/**
121	* Links a mapping object to a primary object.
122	*
123	* @returns IPRT status code.
124	* @retval VINF_SUCCESS on success.
125	* @retval VINF_NO_MEMORY if we couldn't expand the mapping array of the parent.
126	* @param pParent The parent (primary) memory object.
127	* @param pChild The child (mapping) memory object.
128	*/
129	static int rtR0MemObjLink(PRTR0MEMOBJINTERNAL pParent, PRTR0MEMOBJINTERNAL pChild)
130	{
131	uint32_t i;
132
133	/* sanity */
134	Assert(rtR0MemObjIsMapping(pChild));
135	Assert(!rtR0MemObjIsMapping(pParent));
136
137	/* expand the array? */
138	i = pParent->uRel.Parent.cMappings;
139	if (i >= pParent->uRel.Parent.cMappingsAllocated)
140	{
141	void *pv = RTMemRealloc(pParent->uRel.Parent.papMappings,
142	(i + 32) * sizeof(pParent->uRel.Parent.papMappings[0]));
143	if (!pv)
144	return VERR_NO_MEMORY;
145	pParent->uRel.Parent.papMappings = (PPRTR0MEMOBJINTERNAL)pv;
146	pParent->uRel.Parent.cMappingsAllocated = i + 32;
147	Assert(i == pParent->uRel.Parent.cMappings);
148	}
149
150	/* do the linking. */
151	pParent->uRel.Parent.papMappings[i] = pChild;
152	pParent->uRel.Parent.cMappings++;
153	pChild->uRel.Child.pParent = pParent;
154
155	return VINF_SUCCESS;
156	}
157
158
159	/**
160	* Checks if this is mapping or not.
161	*
162	* @returns true if it's a mapping, otherwise false.
163	* @param MemObj The ring-0 memory object handle.
164	*/
165	RTR0DECL(bool) RTR0MemObjIsMapping(RTR0MEMOBJ MemObj)
166	{
167	/* Validate the object handle. */
168	PRTR0MEMOBJINTERNAL pMem;
169	AssertPtrReturn(MemObj, false);
170	pMem = (PRTR0MEMOBJINTERNAL)MemObj;
171	AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), false);
172	AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), false);
173
174	/* hand it on to the inlined worker. */
175	return rtR0MemObjIsMapping(pMem);
176	}
177	RT_EXPORT_SYMBOL(RTR0MemObjIsMapping);
178
179
180	/**
181	* Gets the address of a ring-0 memory object.
182	*
183	* @returns The address of the memory object.
184	* @returns NULL if the handle is invalid (asserts in strict builds) or if there isn't any mapping.
185	* @param MemObj The ring-0 memory object handle.
186	*/
187	RTR0DECL(void *) RTR0MemObjAddress(RTR0MEMOBJ MemObj)
188	{
189	/* Validate the object handle. */
190	PRTR0MEMOBJINTERNAL pMem;
191	if (RT_UNLIKELY(MemObj == NIL_RTR0MEMOBJ))
192	return NULL;
193	AssertPtrReturn(MemObj, NULL);
194	pMem = (PRTR0MEMOBJINTERNAL)MemObj;
195	AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), NULL);
196	AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), NULL);
197
198	/* return the mapping address. */
199	return pMem->pv;
200	}
201	RT_EXPORT_SYMBOL(RTR0MemObjAddress);
202
203
204	/**
205	* Gets the ring-3 address of a ring-0 memory object.
206	*
207	* This only applies to ring-0 memory object with ring-3 mappings of some kind, i.e.
208	* locked user memory, reserved user address space and user mappings. This API should
209	* not be used on any other objects.
210	*
211	* @returns The address of the memory object.
212	* @returns NIL_RTR3PTR if the handle is invalid or if it's not an object with a ring-3 mapping.
213	* Strict builds will assert in both cases.
214	* @param MemObj The ring-0 memory object handle.
215	*/
216	RTR0DECL(RTR3PTR) RTR0MemObjAddressR3(RTR0MEMOBJ MemObj)
217	{
218	PRTR0MEMOBJINTERNAL pMem;
219
220	/* Validate the object handle. */
221	if (RT_UNLIKELY(MemObj == NIL_RTR0MEMOBJ))
222	return NIL_RTR3PTR;
223	AssertPtrReturn(MemObj, NIL_RTR3PTR);
224	pMem = (PRTR0MEMOBJINTERNAL)MemObj;
225	AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), NIL_RTR3PTR);
226	AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), NIL_RTR3PTR);
227	if (RT_UNLIKELY( ( pMem->enmType != RTR0MEMOBJTYPE_MAPPING
228	\|\| pMem->u.Mapping.R0Process == NIL_RTR0PROCESS)
229	&& ( pMem->enmType != RTR0MEMOBJTYPE_LOCK
230	\|\| pMem->u.Lock.R0Process == NIL_RTR0PROCESS)
231	&& ( pMem->enmType != RTR0MEMOBJTYPE_PHYS_NC
232	\|\| pMem->u.Lock.R0Process == NIL_RTR0PROCESS)
233	&& ( pMem->enmType != RTR0MEMOBJTYPE_RES_VIRT
234	\|\| pMem->u.ResVirt.R0Process == NIL_RTR0PROCESS)))
235	return NIL_RTR3PTR;
236
237	/* return the mapping address. */
238	return (RTR3PTR)pMem->pv;
239	}
240	RT_EXPORT_SYMBOL(RTR0MemObjAddressR3);
241
242
243	/**
244	* Gets the size of a ring-0 memory object.
245	*
246	* The returned value may differ from the one specified to the API creating the
247	* object because of alignment adjustments. The minimal alignment currently
248	* employed by any API is PAGE_SIZE, so the result can safely be shifted by
249	* PAGE_SHIFT to calculate a page count.
250	*
251	* @returns The object size.
252	* @returns 0 if the handle is invalid (asserts in strict builds) or if there isn't any mapping.
253	* @param MemObj The ring-0 memory object handle.
254	*/
255	RTR0DECL(size_t) RTR0MemObjSize(RTR0MEMOBJ MemObj)
256	{
257	PRTR0MEMOBJINTERNAL pMem;
258
259	/* Validate the object handle. */
260	if (RT_UNLIKELY(MemObj == NIL_RTR0MEMOBJ))
261	return 0;
262	AssertPtrReturn(MemObj, 0);
263	pMem = (PRTR0MEMOBJINTERNAL)MemObj;
264	AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), 0);
265	AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), 0);
266	AssertMsg(RT_ALIGN_Z(pMem->cb, PAGE_SIZE) == pMem->cb, ("%#zx\n", pMem->cb));
267
268	/* return the size. */
269	return pMem->cb;
270	}
271	RT_EXPORT_SYMBOL(RTR0MemObjSize);
272
273
274	/**
275	* Get the physical address of an page in the memory object.
276	*
277	* @returns The physical address.
278	* @returns NIL_RTHCPHYS if the object doesn't contain fixed physical pages.
279	* @returns NIL_RTHCPHYS if the iPage is out of range.
280	* @returns NIL_RTHCPHYS if the object handle isn't valid.
281	* @param MemObj The ring-0 memory object handle.
282	* @param iPage The page number within the object.
283	*/
284	/* Work around gcc bug 55940 */
285	#if defined(__GNUC__) && defined(RT_ARCH_X86) && (__GNUC__ * 100 + __GNUC_MINOR__) == 407
286	__attribute__((__optimize__ ("no-shrink-wrap")))
287	#endif
288	RTR0DECL(RTHCPHYS) RTR0MemObjGetPagePhysAddr(RTR0MEMOBJ MemObj, size_t iPage)
289	{
290	/* Validate the object handle. */
291	PRTR0MEMOBJINTERNAL pMem;
292	size_t cPages;
293	AssertPtrReturn(MemObj, NIL_RTHCPHYS);
294	pMem = (PRTR0MEMOBJINTERNAL)MemObj;
295	AssertReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, NIL_RTHCPHYS);
296	AssertReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, NIL_RTHCPHYS);
297	AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), NIL_RTHCPHYS);
298	AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), NIL_RTHCPHYS);
299	cPages = (pMem->cb >> PAGE_SHIFT);
300	if (iPage >= cPages)
301	{
302	/* permit: while (RTR0MemObjGetPagePhysAddr(pMem, iPage++) != NIL_RTHCPHYS) {} */
303	if (iPage == cPages)
304	return NIL_RTHCPHYS;
305	AssertReturn(iPage < (pMem->cb >> PAGE_SHIFT), NIL_RTHCPHYS);
306	}
307
308	/*
309	* We know the address of physically contiguous allocations and mappings.
310	*/
311	if (pMem->enmType == RTR0MEMOBJTYPE_CONT)
312	return pMem->u.Cont.Phys + iPage * PAGE_SIZE;
313	if (pMem->enmType == RTR0MEMOBJTYPE_PHYS)
314	return pMem->u.Phys.PhysBase + iPage * PAGE_SIZE;
315
316	/*
317	* Do the job.
318	*/
319	return rtR0MemObjNativeGetPagePhysAddr(pMem, iPage);
320	}
321	RT_EXPORT_SYMBOL(RTR0MemObjGetPagePhysAddr);
322
323
324	/**
325	* Checks whether the allocation was zero initialized or not.
326	*
327	* This only works on allocations. It is not meaningful for mappings, reserved
328	* memory and entered physical address, and will return false for these.
329	*
330	* @returns true if the allocation was initialized to zero at allocation time,
331	* false if not or query not meaningful to the object type.
332	* @param hMemObj The ring-0 memory object to be freed.
333	*
334	* @remarks It can be expected that memory allocated in the same fashion will
335	* have the same initialization state. So, if this returns true for
336	* one allocation it will return true for all other similarly made
337	* allocations.
338	*/
339	RTR0DECL(bool) RTR0MemObjWasZeroInitialized(RTR0MEMOBJ hMemObj)
340	{
341	PRTR0MEMOBJINTERNAL pMem;
342
343	/* Validate the object handle. */
344	if (RT_UNLIKELY(hMemObj == NIL_RTR0MEMOBJ))
345	return false;
346	AssertPtrReturn(hMemObj, false);
347	pMem = (PRTR0MEMOBJINTERNAL)hMemObj;
348	AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), false);
349	AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), false);
350	Assert( (pMem->fFlags & (RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC \| RTR0MEMOBJ_FLAGS_UNINITIALIZED_AT_ALLOC))
351	!= (RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC \| RTR0MEMOBJ_FLAGS_UNINITIALIZED_AT_ALLOC));
352
353	/* return the alloc init state. */
354	return (pMem->fFlags & (RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC \| RTR0MEMOBJ_FLAGS_UNINITIALIZED_AT_ALLOC))
355	== RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC;
356	}
357	RT_EXPORT_SYMBOL(RTR0MemObjWasZeroInitialized);
358
359
360	/**
361	* Frees a ring-0 memory object.
362	*
363	* @returns IPRT status code.
364	* @retval VERR_INVALID_HANDLE if
365	* @param MemObj The ring-0 memory object to be freed. NIL is
366	* accepted.
367	* @param fFreeMappings Whether or not to free mappings of the object.
368	*/
369	RTR0DECL(int) RTR0MemObjFree(RTR0MEMOBJ MemObj, bool fFreeMappings)
370	{
371	/*
372	* Validate the object handle.
373	*/
374	PRTR0MEMOBJINTERNAL pMem;
375	int rc;
376
377	if (MemObj == NIL_RTR0MEMOBJ)
378	return VINF_SUCCESS;
379	AssertPtrReturn(MemObj, VERR_INVALID_HANDLE);
380	pMem = (PRTR0MEMOBJINTERNAL)MemObj;
381	AssertReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
382	AssertReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
383	RT_ASSERT_PREEMPTIBLE();
384
385	/*
386	* Deal with mappings according to fFreeMappings.
387	*/
388	if ( !rtR0MemObjIsMapping(pMem)
389	&& pMem->uRel.Parent.cMappings > 0)
390	{
391	/* fail if not requested to free mappings. */
392	if (!fFreeMappings)
393	return VERR_MEMORY_BUSY;
394
395	while (pMem->uRel.Parent.cMappings > 0)
396	{
397	PRTR0MEMOBJINTERNAL pChild = pMem->uRel.Parent.papMappings[--pMem->uRel.Parent.cMappings];
398	pMem->uRel.Parent.papMappings[pMem->uRel.Parent.cMappings] = NULL;
399
400	/* sanity checks. */
401	AssertPtr(pChild);
402	AssertFatal(pChild->u32Magic == RTR0MEMOBJ_MAGIC);
403	AssertFatal(pChild->enmType > RTR0MEMOBJTYPE_INVALID && pChild->enmType < RTR0MEMOBJTYPE_END);
404	AssertFatal(rtR0MemObjIsMapping(pChild));
405
406	/* free the mapping. */
407	rc = rtR0MemObjNativeFree(pChild);
408	if (RT_FAILURE(rc))
409	{
410	Log(("RTR0MemObjFree: failed to free mapping %p: %p %#zx; rc=%Rrc\n", pChild, pChild->pv, pChild->cb, rc));
411	pMem->uRel.Parent.papMappings[pMem->uRel.Parent.cMappings++] = pChild;
412	return rc;
413	}
414
415	pChild->u32Magic++;
416	pChild->enmType = RTR0MEMOBJTYPE_END;
417	RTMemFree(pChild);
418	}
419	}
420
421	/*
422	* Free this object.
423	*/
424	rc = rtR0MemObjNativeFree(pMem);
425	if (RT_SUCCESS(rc))
426	{
427	/*
428	* Ok, it was freed just fine. Now, if it's a mapping we'll have to remove it from the parent.
429	*/
430	if (rtR0MemObjIsMapping(pMem))
431	{
432	PRTR0MEMOBJINTERNAL pParent = pMem->uRel.Child.pParent;
433	uint32_t i;
434
435	/* sanity checks */
436	AssertPtr(pParent);
437	AssertFatal(pParent->u32Magic == RTR0MEMOBJ_MAGIC);
438	AssertFatal(pParent->enmType > RTR0MEMOBJTYPE_INVALID && pParent->enmType < RTR0MEMOBJTYPE_END);
439	AssertFatal(!rtR0MemObjIsMapping(pParent));
440	AssertFatal(pParent->uRel.Parent.cMappings > 0);
441	AssertPtr(pParent->uRel.Parent.papMappings);
442
443	/* locate and remove from the array of mappings. */
444	i = pParent->uRel.Parent.cMappings;
445	while (i-- > 0)
446	{
447	if (pParent->uRel.Parent.papMappings[i] == pMem)
448	{
449	pParent->uRel.Parent.papMappings[i] = pParent->uRel.Parent.papMappings[--pParent->uRel.Parent.cMappings];
450	break;
451	}
452	}
453	Assert(i != UINT32_MAX);
454	}
455	else
456	Assert(pMem->uRel.Parent.cMappings == 0);
457
458	/*
459	* Finally, destroy the handle.
460	*/
461	pMem->u32Magic++;
462	pMem->enmType = RTR0MEMOBJTYPE_END;
463	if (!rtR0MemObjIsMapping(pMem))
464	RTMemFree(pMem->uRel.Parent.papMappings);
465	RTMemFree(pMem);
466	}
467	else
468	Log(("RTR0MemObjFree: failed to free %p: %d %p %#zx; rc=%Rrc\n",
469	pMem, pMem->enmType, pMem->pv, pMem->cb, rc));
470	return rc;
471	}
472	RT_EXPORT_SYMBOL(RTR0MemObjFree);
473
474
475
476	RTR0DECL(int) RTR0MemObjAllocPageTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
477	{
478	/* sanity checks. */
479	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
480	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
481	*pMemObj = NIL_RTR0MEMOBJ;
482	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
483	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
484	RT_ASSERT_PREEMPTIBLE();
485
486	/* do the allocation. */
487	return rtR0MemObjNativeAllocPage(pMemObj, cbAligned, fExecutable, pszTag);
488	}
489	RT_EXPORT_SYMBOL(RTR0MemObjAllocPageTag);
490
491
492	RTR0DECL(int) RTR0MemObjAllocLargeTag(PRTR0MEMOBJ pMemObj, size_t cb, size_t cbLargePage, uint32_t fFlags, const char *pszTag)
493	{
494	/* sanity checks. */
495	const size_t cbAligned = RT_ALIGN_Z(cb, cbLargePage);
496	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
497	*pMemObj = NIL_RTR0MEMOBJ;
498	#ifdef RT_ARCH_AMD64
499	AssertReturn(cbLargePage == _2M \|\| cbLargePage == _1G, VERR_OUT_OF_RANGE);
500	#elif defined(RT_ARCH_X86)
501	AssertReturn(cbLargePage == _2M \|\| cbLargePage == _4M, VERR_OUT_OF_RANGE);
502	#else
503	AssertReturn(RT_IS_POWER_OF_TWO(cbLargePage), VERR_NOT_POWER_OF_TWO);
504	AssertReturn(cbLargePage > PAGE_SIZE, VERR_OUT_OF_RANGE);
505	#endif
506	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
507	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
508	AssertReturn(!(fFlags & ~RTMEMOBJ_ALLOC_LARGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
509	RT_ASSERT_PREEMPTIBLE();
510
511	/* do the allocation. */
512	return rtR0MemObjNativeAllocLarge(pMemObj, cbAligned, cbLargePage, fFlags, pszTag);
513	}
514	RT_EXPORT_SYMBOL(RTR0MemObjAllocLargeTag);
515
516
517	/**
518	* Fallback implementation of rtR0MemObjNativeAllocLarge and implements single
519	* page allocation using rtR0MemObjNativeAllocPhys.
520	*/
521	DECLHIDDEN(int) rtR0MemObjFallbackAllocLarge(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, size_t cbLargePage, uint32_t fFlags,
522	const char *pszTag)
523	{
524	RT_NOREF(pszTag, fFlags);
525	if (cb == cbLargePage)
526	return rtR0MemObjNativeAllocPhys(ppMem, cb, NIL_RTHCPHYS, cbLargePage, pszTag);
527	return VERR_NOT_SUPPORTED;
528	}
529
530
531	RTR0DECL(int) RTR0MemObjAllocLowTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
532	{
533	/* sanity checks. */
534	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
535	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
536	*pMemObj = NIL_RTR0MEMOBJ;
537	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
538	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
539	RT_ASSERT_PREEMPTIBLE();
540
541	/* do the allocation. */
542	return rtR0MemObjNativeAllocLow(pMemObj, cbAligned, fExecutable, pszTag);
543	}
544	RT_EXPORT_SYMBOL(RTR0MemObjAllocLowTag);
545
546
547	RTR0DECL(int) RTR0MemObjAllocContTag(PRTR0MEMOBJ pMemObj, size_t cb, bool fExecutable, const char *pszTag)
548	{
549	/* sanity checks. */
550	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
551	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
552	*pMemObj = NIL_RTR0MEMOBJ;
553	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
554	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
555	RT_ASSERT_PREEMPTIBLE();
556
557	/* do the allocation. */
558	return rtR0MemObjNativeAllocCont(pMemObj, cbAligned, fExecutable, pszTag);
559	}
560	RT_EXPORT_SYMBOL(RTR0MemObjAllocContTag);
561
562
563	RTR0DECL(int) RTR0MemObjLockUserTag(PRTR0MEMOBJ pMemObj, RTR3PTR R3Ptr, size_t cb,
564	uint32_t fAccess, RTR0PROCESS R0Process, const char *pszTag)
565	{
566	/* sanity checks. */
567	const size_t cbAligned = RT_ALIGN_Z(cb + (R3Ptr & PAGE_OFFSET_MASK), PAGE_SIZE);
568	RTR3PTR const R3PtrAligned = (R3Ptr & ~(RTR3PTR)PAGE_OFFSET_MASK);
569	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
570	*pMemObj = NIL_RTR0MEMOBJ;
571	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
572	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
573	if (R0Process == NIL_RTR0PROCESS)
574	R0Process = RTR0ProcHandleSelf();
575	AssertReturn(!(fAccess & ~(RTMEM_PROT_READ \| RTMEM_PROT_WRITE)), VERR_INVALID_PARAMETER);
576	AssertReturn(fAccess, VERR_INVALID_PARAMETER);
577	RT_ASSERT_PREEMPTIBLE();
578
579	/* do the locking. */
580	return rtR0MemObjNativeLockUser(pMemObj, R3PtrAligned, cbAligned, fAccess, R0Process, pszTag);
581	}
582	RT_EXPORT_SYMBOL(RTR0MemObjLockUserTag);
583
584
585	RTR0DECL(int) RTR0MemObjLockKernelTag(PRTR0MEMOBJ pMemObj, void pv, size_t cb, uint32_t fAccess, const char pszTag)
586	{
587	/* sanity checks. */
588	const size_t cbAligned = RT_ALIGN_Z(cb + ((uintptr_t)pv & PAGE_OFFSET_MASK), PAGE_SIZE);
589	void * const pvAligned = (void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK);
590	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
591	*pMemObj = NIL_RTR0MEMOBJ;
592	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
593	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
594	AssertPtrReturn(pvAligned, VERR_INVALID_POINTER);
595	AssertReturn(!(fAccess & ~(RTMEM_PROT_READ \| RTMEM_PROT_WRITE)), VERR_INVALID_PARAMETER);
596	AssertReturn(fAccess, VERR_INVALID_PARAMETER);
597	RT_ASSERT_PREEMPTIBLE();
598
599	/* do the allocation. */
600	return rtR0MemObjNativeLockKernel(pMemObj, pvAligned, cbAligned, fAccess, pszTag);
601	}
602	RT_EXPORT_SYMBOL(RTR0MemObjLockKernelTag);
603
604
605	RTR0DECL(int) RTR0MemObjAllocPhysTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
606	{
607	/* sanity checks. */
608	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
609	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
610	*pMemObj = NIL_RTR0MEMOBJ;
611	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
612	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
613	AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
614	RT_ASSERT_PREEMPTIBLE();
615
616	/* do the allocation. */
617	return rtR0MemObjNativeAllocPhys(pMemObj, cbAligned, PhysHighest, PAGE_SIZE /* page aligned */, pszTag);
618	}
619	RT_EXPORT_SYMBOL(RTR0MemObjAllocPhysTag);
620
621
622	RTR0DECL(int) RTR0MemObjAllocPhysExTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, size_t uAlignment, const char *pszTag)
623	{
624	/* sanity checks. */
625	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
626	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
627	*pMemObj = NIL_RTR0MEMOBJ;
628	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
629	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
630	AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
631	if (uAlignment == 0)
632	uAlignment = PAGE_SIZE;
633	AssertReturn( uAlignment == PAGE_SIZE
634	\|\| uAlignment == _2M
635	\|\| uAlignment == _4M
636	\|\| uAlignment == _1G,
637	VERR_INVALID_PARAMETER);
638	#if HC_ARCH_BITS == 32
639	/* Memory allocated in this way is typically mapped into kernel space as well; simply
640	don't allow this on 32 bits hosts as the kernel space is too crowded already. */
641	if (uAlignment != PAGE_SIZE)
642	return VERR_NOT_SUPPORTED;
643	#endif
644	RT_ASSERT_PREEMPTIBLE();
645
646	/* do the allocation. */
647	return rtR0MemObjNativeAllocPhys(pMemObj, cbAligned, PhysHighest, uAlignment, pszTag);
648	}
649	RT_EXPORT_SYMBOL(RTR0MemObjAllocPhysExTag);
650
651
652	RTR0DECL(int) RTR0MemObjAllocPhysNCTag(PRTR0MEMOBJ pMemObj, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
653	{
654	/* sanity checks. */
655	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
656	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
657	*pMemObj = NIL_RTR0MEMOBJ;
658	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
659	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
660	AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
661	RT_ASSERT_PREEMPTIBLE();
662
663	/* do the allocation. */
664	return rtR0MemObjNativeAllocPhysNC(pMemObj, cbAligned, PhysHighest, pszTag);
665	}
666	RT_EXPORT_SYMBOL(RTR0MemObjAllocPhysNCTag);
667
668
669	RTR0DECL(int) RTR0MemObjEnterPhysTag(PRTR0MEMOBJ pMemObj, RTHCPHYS Phys, size_t cb, uint32_t uCachePolicy, const char *pszTag)
670	{
671	/* sanity checks. */
672	const size_t cbAligned = RT_ALIGN_Z(cb + (Phys & PAGE_OFFSET_MASK), PAGE_SIZE);
673	const RTHCPHYS PhysAligned = Phys & ~(RTHCPHYS)PAGE_OFFSET_MASK;
674	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
675	*pMemObj = NIL_RTR0MEMOBJ;
676	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
677	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
678	AssertReturn(Phys != NIL_RTHCPHYS, VERR_INVALID_PARAMETER);
679	AssertReturn( uCachePolicy == RTMEM_CACHE_POLICY_DONT_CARE
680	\|\| uCachePolicy == RTMEM_CACHE_POLICY_MMIO,
681	VERR_INVALID_PARAMETER);
682	RT_ASSERT_PREEMPTIBLE();
683
684	/* do the allocation. */
685	return rtR0MemObjNativeEnterPhys(pMemObj, PhysAligned, cbAligned, uCachePolicy, pszTag);
686	}
687	RT_EXPORT_SYMBOL(RTR0MemObjEnterPhysTag);
688
689
690	RTR0DECL(int) RTR0MemObjReserveKernelTag(PRTR0MEMOBJ pMemObj, void pvFixed, size_t cb, size_t uAlignment, const char pszTag)
691	{
692	/* sanity checks. */
693	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
694	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
695	*pMemObj = NIL_RTR0MEMOBJ;
696	if (uAlignment == 0)
697	uAlignment = PAGE_SIZE;
698	AssertReturn(uAlignment == PAGE_SIZE \|\| uAlignment == _2M \|\| uAlignment == _4M, VERR_INVALID_PARAMETER);
699	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
700	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
701	if (pvFixed != (void *)-1)
702	AssertReturn(!((uintptr_t)pvFixed & (uAlignment - 1)), VERR_INVALID_PARAMETER);
703	RT_ASSERT_PREEMPTIBLE();
704
705	/* do the reservation. */
706	return rtR0MemObjNativeReserveKernel(pMemObj, pvFixed, cbAligned, uAlignment, pszTag);
707	}
708	RT_EXPORT_SYMBOL(RTR0MemObjReserveKernelTag);
709
710
711	RTR0DECL(int) RTR0MemObjReserveUserTag(PRTR0MEMOBJ pMemObj, RTR3PTR R3PtrFixed, size_t cb,
712	size_t uAlignment, RTR0PROCESS R0Process, const char *pszTag)
713	{
714	/* sanity checks. */
715	const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
716	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
717	*pMemObj = NIL_RTR0MEMOBJ;
718	if (uAlignment == 0)
719	uAlignment = PAGE_SIZE;
720	AssertReturn(uAlignment == PAGE_SIZE \|\| uAlignment == _2M \|\| uAlignment == _4M, VERR_INVALID_PARAMETER);
721	AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
722	AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
723	if (R3PtrFixed != (RTR3PTR)-1)
724	AssertReturn(!(R3PtrFixed & (uAlignment - 1)), VERR_INVALID_PARAMETER);
725	if (R0Process == NIL_RTR0PROCESS)
726	R0Process = RTR0ProcHandleSelf();
727	RT_ASSERT_PREEMPTIBLE();
728
729	/* do the reservation. */
730	return rtR0MemObjNativeReserveUser(pMemObj, R3PtrFixed, cbAligned, uAlignment, R0Process, pszTag);
731	}
732	RT_EXPORT_SYMBOL(RTR0MemObjReserveUserTag);
733
734
735	RTR0DECL(int) RTR0MemObjMapKernelTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed,
736	size_t uAlignment, unsigned fProt, const char *pszTag)
737	{
738	return RTR0MemObjMapKernelExTag(pMemObj, MemObjToMap, pvFixed, uAlignment, fProt, 0, 0, pszTag);
739	}
740	RT_EXPORT_SYMBOL(RTR0MemObjMapKernelTag);
741
742
743	RTR0DECL(int) RTR0MemObjMapKernelExTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, void *pvFixed, size_t uAlignment,
744	unsigned fProt, size_t offSub, size_t cbSub, const char *pszTag)
745	{
746	PRTR0MEMOBJINTERNAL pMemToMap;
747	PRTR0MEMOBJINTERNAL pNew;
748	int rc;
749
750	/* sanity checks. */
751	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
752	*pMemObj = NIL_RTR0MEMOBJ;
753	AssertPtrReturn(MemObjToMap, VERR_INVALID_HANDLE);
754	pMemToMap = (PRTR0MEMOBJINTERNAL)MemObjToMap;
755	AssertReturn(pMemToMap->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
756	AssertReturn(pMemToMap->enmType > RTR0MEMOBJTYPE_INVALID && pMemToMap->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
757	AssertReturn(!rtR0MemObjIsMapping(pMemToMap), VERR_INVALID_PARAMETER);
758	AssertReturn(pMemToMap->enmType != RTR0MEMOBJTYPE_RES_VIRT, VERR_INVALID_PARAMETER);
759	if (uAlignment == 0)
760	uAlignment = PAGE_SIZE;
761	AssertReturn(uAlignment == PAGE_SIZE \|\| uAlignment == _2M \|\| uAlignment == _4M, VERR_INVALID_PARAMETER);
762	if (pvFixed != (void *)-1)
763	AssertReturn(!((uintptr_t)pvFixed & (uAlignment - 1)), VERR_INVALID_PARAMETER);
764	AssertReturn(fProt != RTMEM_PROT_NONE, VERR_INVALID_PARAMETER);
765	AssertReturn(!(fProt & ~(RTMEM_PROT_READ \| RTMEM_PROT_WRITE \| RTMEM_PROT_EXEC)), VERR_INVALID_PARAMETER);
766	AssertReturn(!(offSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
767	AssertReturn(offSub < pMemToMap->cb, VERR_INVALID_PARAMETER);
768	AssertReturn(!(cbSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
769	AssertReturn(cbSub <= pMemToMap->cb, VERR_INVALID_PARAMETER);
770	AssertReturn((!offSub && !cbSub) \|\| (offSub + cbSub) <= pMemToMap->cb, VERR_INVALID_PARAMETER);
771	RT_ASSERT_PREEMPTIBLE();
772
773	/* adjust the request to simplify the native code. */
774	if (offSub == 0 && cbSub == pMemToMap->cb)
775	cbSub = 0;
776
777	/* do the mapping. */
778	rc = rtR0MemObjNativeMapKernel(&pNew, pMemToMap, pvFixed, uAlignment, fProt, offSub, cbSub, pszTag);
779	if (RT_SUCCESS(rc))
780	{
781	/* link it. */
782	rc = rtR0MemObjLink(pMemToMap, pNew);
783	if (RT_SUCCESS(rc))
784	*pMemObj = pNew;
785	else
786	{
787	/* damn, out of memory. bail out. */
788	int rc2 = rtR0MemObjNativeFree(pNew);
789	AssertRC(rc2);
790	pNew->u32Magic++;
791	pNew->enmType = RTR0MEMOBJTYPE_END;
792	RTMemFree(pNew);
793	}
794	}
795
796	return rc;
797	}
798	RT_EXPORT_SYMBOL(RTR0MemObjMapKernelExTag);
799
800
801	RTR0DECL(int) RTR0MemObjMapUserTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed,
802	size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process, const char *pszTag)
803	{
804	return RTR0MemObjMapUserExTag(pMemObj, MemObjToMap, R3PtrFixed, uAlignment, fProt, R0Process, 0, 0, pszTag);
805	}
806	RT_EXPORT_SYMBOL(RTR0MemObjMapUserTag);
807
808
809	RTR0DECL(int) RTR0MemObjMapUserExTag(PRTR0MEMOBJ pMemObj, RTR0MEMOBJ MemObjToMap, RTR3PTR R3PtrFixed, size_t uAlignment,
810	unsigned fProt, RTR0PROCESS R0Process, size_t offSub, size_t cbSub, const char *pszTag)
811	{
812	/* sanity checks. */
813	PRTR0MEMOBJINTERNAL pMemToMap;
814	PRTR0MEMOBJINTERNAL pNew;
815	int rc;
816	AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
817	pMemToMap = (PRTR0MEMOBJINTERNAL)MemObjToMap;
818	*pMemObj = NIL_RTR0MEMOBJ;
819	AssertPtrReturn(MemObjToMap, VERR_INVALID_HANDLE);
820	AssertReturn(pMemToMap->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
821	AssertReturn(pMemToMap->enmType > RTR0MEMOBJTYPE_INVALID && pMemToMap->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
822	AssertReturn(!rtR0MemObjIsMapping(pMemToMap), VERR_INVALID_PARAMETER);
823	AssertReturn(pMemToMap->enmType != RTR0MEMOBJTYPE_RES_VIRT, VERR_INVALID_PARAMETER);
824	if (uAlignment == 0)
825	uAlignment = PAGE_SIZE;
826	AssertReturn(uAlignment == PAGE_SIZE \|\| uAlignment == _2M \|\| uAlignment == _4M, VERR_INVALID_PARAMETER);
827	if (R3PtrFixed != (RTR3PTR)-1)
828	AssertReturn(!(R3PtrFixed & (uAlignment - 1)), VERR_INVALID_PARAMETER);
829	AssertReturn(fProt != RTMEM_PROT_NONE, VERR_INVALID_PARAMETER);
830	AssertReturn(!(fProt & ~(RTMEM_PROT_READ \| RTMEM_PROT_WRITE \| RTMEM_PROT_EXEC)), VERR_INVALID_PARAMETER);
831	AssertReturn(!(offSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
832	AssertReturn(offSub < pMemToMap->cb, VERR_INVALID_PARAMETER);
833	AssertReturn(!(cbSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
834	AssertReturn(cbSub <= pMemToMap->cb, VERR_INVALID_PARAMETER);
835	AssertReturn((!offSub && !cbSub) \|\| (offSub + cbSub) <= pMemToMap->cb, VERR_INVALID_PARAMETER);
836	if (R0Process == NIL_RTR0PROCESS)
837	R0Process = RTR0ProcHandleSelf();
838	RT_ASSERT_PREEMPTIBLE();
839
840	/* adjust the request to simplify the native code. */
841	if (offSub == 0 && cbSub == pMemToMap->cb)
842	cbSub = 0;
843
844	/* do the mapping. */
845	rc = rtR0MemObjNativeMapUser(&pNew, pMemToMap, R3PtrFixed, uAlignment, fProt, R0Process, offSub, cbSub, pszTag);
846	if (RT_SUCCESS(rc))
847	{
848	/* link it. */
849	rc = rtR0MemObjLink(pMemToMap, pNew);
850	if (RT_SUCCESS(rc))
851	*pMemObj = pNew;
852	else
853	{
854	/* damn, out of memory. bail out. */
855	int rc2 = rtR0MemObjNativeFree(pNew);
856	AssertRC(rc2);
857	pNew->u32Magic++;
858	pNew->enmType = RTR0MEMOBJTYPE_END;
859	RTMemFree(pNew);
860	}
861	}
862
863	return rc;
864	}
865	RT_EXPORT_SYMBOL(RTR0MemObjMapUserExTag);
866
867
868	RTR0DECL(int) RTR0MemObjProtect(RTR0MEMOBJ hMemObj, size_t offSub, size_t cbSub, uint32_t fProt)
869	{
870	PRTR0MEMOBJINTERNAL pMemObj;
871	int rc;
872
873	/* sanity checks. */
874	pMemObj = (PRTR0MEMOBJINTERNAL)hMemObj;
875	AssertPtrReturn(pMemObj, VERR_INVALID_HANDLE);
876	AssertReturn(pMemObj->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
877	AssertReturn(pMemObj->enmType > RTR0MEMOBJTYPE_INVALID && pMemObj->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
878	AssertReturn(rtR0MemObjIsProtectable(pMemObj), VERR_INVALID_PARAMETER);
879	AssertReturn(!(offSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
880	AssertReturn(offSub < pMemObj->cb, VERR_INVALID_PARAMETER);
881	AssertReturn(!(cbSub & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
882	AssertReturn(cbSub <= pMemObj->cb, VERR_INVALID_PARAMETER);
883	AssertReturn(offSub + cbSub <= pMemObj->cb, VERR_INVALID_PARAMETER);
884	AssertReturn(!(fProt & ~(RTMEM_PROT_NONE \| RTMEM_PROT_READ \| RTMEM_PROT_WRITE \| RTMEM_PROT_EXEC)), VERR_INVALID_PARAMETER);
885	RT_ASSERT_PREEMPTIBLE();
886
887	/* do the job */
888	rc = rtR0MemObjNativeProtect(pMemObj, offSub, cbSub, fProt);
889	if (RT_SUCCESS(rc))
890	pMemObj->fFlags \|= RTR0MEMOBJ_FLAGS_PROT_CHANGED; /* record it */
891
892	return rc;
893	}
894	RT_EXPORT_SYMBOL(RTR0MemObjProtect);
895

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp@ 98103

Download in other formats: