memobj-r0drv-nt.cpp@ 100357

Last change on this file since 100357 was 100357, checked in by vboxsync, 18 months ago
Runtime/RTR0MemObj*: Add PhysHighest parameter to RTR0MemObjAllocCont to indicate the maximum allowed physical address for an allocation, bugref:10457 [second attempt]
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 46.9 KB

Line
1	/* $Id: memobj-r0drv-nt.cpp 100357 2023-07-04 07:00:26Z vboxsync $ */
2	/** @file
3	* IPRT - Ring-0 Memory Objects, NT.
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	#include "the-nt-kernel.h"
42
43	#include <iprt/memobj.h>
44	#include <iprt/alloc.h>
45	#include <iprt/assert.h>
46	#include <iprt/err.h>
47	#include <iprt/log.h>
48	#include <iprt/param.h>
49	#include <iprt/string.h>
50	#include <iprt/process.h>
51	#include "internal/memobj.h"
52	#include "internal-r0drv-nt.h"
53
54
55	/*********************************************************************************************************************************
56	* Defined Constants And Macros *
57	*********************************************************************************************************************************/
58	/** Maximum number of bytes we try to lock down in one go.
59	* This is supposed to have a limit right below 256MB, but this appears
60	* to actually be much lower. The values here have been determined experimentally.
61	*/
62	#ifdef RT_ARCH_X86
63	# define MAX_LOCK_MEM_SIZE (3210241024) /* 32MB */
64	#endif
65	#ifdef RT_ARCH_AMD64
66	# define MAX_LOCK_MEM_SIZE (2410241024) /* 24MB */
67	#endif
68
69	/* Newer WDK constants: */
70	#ifndef MM_ALLOCATE_REQUIRE_CONTIGUOUS_CHUNKS
71	# define MM_ALLOCATE_REQUIRE_CONTIGUOUS_CHUNKS 0x20
72	#endif
73	#ifndef MM_ALLOCATE_FAST_LARGE_PAGES
74	# define MM_ALLOCATE_FAST_LARGE_PAGES 0x40
75	#endif
76
77
78	/*********************************************************************************************************************************
79	* Structures and Typedefs *
80	*********************************************************************************************************************************/
81	/**
82	* The NT version of the memory object structure.
83	*/
84	typedef struct RTR0MEMOBJNT
85	{
86	/** The core structure. */
87	RTR0MEMOBJINTERNAL Core;
88	/** Used MmAllocatePagesForMdl(). */
89	bool fAllocatedPagesForMdl;
90	/** Set if this is sub-section of the parent. */
91	bool fSubMapping;
92	/** Pointer returned by MmSecureVirtualMemory */
93	PVOID pvSecureMem;
94	/** The number of PMDLs (memory descriptor lists) in the array. */
95	uint32_t cMdls;
96	/** Array of MDL pointers. (variable size) */
97	PMDL apMdls[1];
98	} RTR0MEMOBJNT;
99	/** Pointer to the NT version of the memory object structure. */
100	typedef RTR0MEMOBJNT *PRTR0MEMOBJNT;
101
102
103
104	DECLHIDDEN(int) rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
105	{
106	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)pMem;
107
108	/*
109	* Deal with it on a per type basis (just as a variation).
110	*/
111	switch (pMemNt->Core.enmType)
112	{
113	case RTR0MEMOBJTYPE_LOW:
114	if (pMemNt->fAllocatedPagesForMdl)
115	{
116	Assert(pMemNt->Core.pv && pMemNt->cMdls == 1 && pMemNt->apMdls[0]);
117	MmUnmapLockedPages(pMemNt->Core.pv, pMemNt->apMdls[0]);
118	pMemNt->Core.pv = NULL;
119	if (pMemNt->pvSecureMem)
120	{
121	g_pfnrtMmUnsecureVirtualMemory(pMemNt->pvSecureMem);
122	pMemNt->pvSecureMem = NULL;
123	}
124
125	g_pfnrtMmFreePagesFromMdl(pMemNt->apMdls[0]);
126	ExFreePool(pMemNt->apMdls[0]);
127	pMemNt->apMdls[0] = NULL;
128	pMemNt->cMdls = 0;
129	break;
130	}
131	AssertFailed();
132	break;
133
134	case RTR0MEMOBJTYPE_PAGE:
135	Assert(pMemNt->Core.pv);
136	if (pMemNt->fAllocatedPagesForMdl)
137	{
138	Assert(pMemNt->Core.pv && pMemNt->cMdls == 1 && pMemNt->apMdls[0]);
139	Assert(pMemNt->pvSecureMem == NULL);
140	MmUnmapLockedPages(pMemNt->Core.pv, pMemNt->apMdls[0]);
141	g_pfnrtMmFreePagesFromMdl(pMemNt->apMdls[0]);
142	ExFreePool(pMemNt->apMdls[0]);
143	}
144	else
145	{
146	if (g_pfnrtExFreePoolWithTag)
147	g_pfnrtExFreePoolWithTag(pMemNt->Core.pv, IPRT_NT_POOL_TAG);
148	else
149	ExFreePool(pMemNt->Core.pv);
150
151	Assert(pMemNt->cMdls == 1 && pMemNt->apMdls[0]);
152	IoFreeMdl(pMemNt->apMdls[0]);
153	}
154	pMemNt->Core.pv = NULL;
155	pMemNt->apMdls[0] = NULL;
156	pMemNt->cMdls = 0;
157	break;
158
159	case RTR0MEMOBJTYPE_CONT:
160	Assert(pMemNt->Core.pv);
161	MmFreeContiguousMemory(pMemNt->Core.pv);
162	pMemNt->Core.pv = NULL;
163
164	Assert(pMemNt->cMdls == 1 && pMemNt->apMdls[0]);
165	IoFreeMdl(pMemNt->apMdls[0]);
166	pMemNt->apMdls[0] = NULL;
167	pMemNt->cMdls = 0;
168	break;
169
170	case RTR0MEMOBJTYPE_PHYS:
171	/* rtR0MemObjNativeEnterPhys? */
172	if (!pMemNt->Core.u.Phys.fAllocated)
173	{
174	Assert(!pMemNt->fAllocatedPagesForMdl);
175	/* Nothing to do here. */
176	break;
177	}
178	RT_FALL_THRU();
179
180	case RTR0MEMOBJTYPE_PHYS_NC:
181	if (pMemNt->fAllocatedPagesForMdl)
182	{
183	g_pfnrtMmFreePagesFromMdl(pMemNt->apMdls[0]);
184	ExFreePool(pMemNt->apMdls[0]);
185	pMemNt->apMdls[0] = NULL;
186	pMemNt->cMdls = 0;
187	break;
188	}
189	AssertFailed();
190	break;
191
192	case RTR0MEMOBJTYPE_LOCK:
193	if (pMemNt->pvSecureMem)
194	{
195	g_pfnrtMmUnsecureVirtualMemory(pMemNt->pvSecureMem);
196	pMemNt->pvSecureMem = NULL;
197	}
198	for (uint32_t i = 0; i < pMemNt->cMdls; i++)
199	{
200	MmUnlockPages(pMemNt->apMdls[i]);
201	IoFreeMdl(pMemNt->apMdls[i]);
202	pMemNt->apMdls[i] = NULL;
203	}
204	break;
205
206	case RTR0MEMOBJTYPE_RES_VIRT:
207	/* if (pMemNt->Core.u.ResVirt.R0Process == NIL_RTR0PROCESS)
208	{
209	}
210	else
211	{
212	}*/
213	AssertMsgFailed(("RTR0MEMOBJTYPE_RES_VIRT\n"));
214	return VERR_INTERNAL_ERROR;
215	break;
216
217	case RTR0MEMOBJTYPE_MAPPING:
218	{
219	PRTR0MEMOBJNT pMemNtParent = (PRTR0MEMOBJNT)pMemNt->Core.uRel.Child.pParent;
220	Assert(pMemNtParent);
221	Assert(pMemNt->Core.pv);
222	Assert((pMemNt->cMdls == 0 && !pMemNt->fSubMapping) \|\| (pMemNt->cMdls == 1 && pMemNt->fSubMapping));
223	if (pMemNtParent->cMdls)
224	{
225	Assert(pMemNtParent->cMdls == 1 && pMemNtParent->apMdls[0]);
226	Assert( pMemNt->Core.u.Mapping.R0Process == NIL_RTR0PROCESS
227	\|\| pMemNt->Core.u.Mapping.R0Process == RTR0ProcHandleSelf());
228	if (!pMemNt->cMdls)
229	MmUnmapLockedPages(pMemNt->Core.pv, pMemNtParent->apMdls[0]);
230	else
231	{
232	MmUnmapLockedPages(pMemNt->Core.pv, pMemNt->apMdls[0]);
233	IoFreeMdl(pMemNt->apMdls[0]);
234	pMemNt->apMdls[0] = NULL;
235	}
236	}
237	else
238	{
239	Assert( pMemNtParent->Core.enmType == RTR0MEMOBJTYPE_PHYS
240	&& !pMemNtParent->Core.u.Phys.fAllocated);
241	Assert(pMemNt->Core.u.Mapping.R0Process == NIL_RTR0PROCESS);
242	Assert(!pMemNt->fSubMapping);
243	MmUnmapIoSpace(pMemNt->Core.pv, pMemNt->Core.cb);
244	}
245	pMemNt->Core.pv = NULL;
246	break;
247	}
248
249	default:
250	AssertMsgFailed(("enmType=%d\n", pMemNt->Core.enmType));
251	return VERR_INTERNAL_ERROR;
252	}
253
254	return VINF_SUCCESS;
255	}
256
257
258	DECLHIDDEN(int) rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
259	{
260	AssertMsgReturn(cb <= _1G, ("%#x\n", cb), VERR_OUT_OF_RANGE); /* for safe size_t -> ULONG */
261	RT_NOREF1(fExecutable);
262
263	/*
264	* Use MmAllocatePagesForMdl if the allocation is a little bit big.
265	*/
266	int rc = VERR_NO_PAGE_MEMORY;
267	if ( cb > _1M
268	&& g_pfnrtMmAllocatePagesForMdl
269	&& g_pfnrtMmFreePagesFromMdl
270	&& g_pfnrtMmMapLockedPagesSpecifyCache)
271	{
272	PHYSICAL_ADDRESS Zero;
273	Zero.QuadPart = 0;
274	PHYSICAL_ADDRESS HighAddr;
275	HighAddr.QuadPart = MAXLONGLONG;
276	PMDL pMdl = g_pfnrtMmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
277	if (pMdl)
278	{
279	if (MmGetMdlByteCount(pMdl) >= cb)
280	{
281	__try
282	{
283	void pv = g_pfnrtMmMapLockedPagesSpecifyCache(pMdl, KernelMode, MmCached, NULL / no base address */,
284	FALSE /* no bug check on failure */, NormalPagePriority);
285	if (pv)
286	{
287	#ifdef RT_ARCH_AMD64
288	if (fExecutable)
289	MmProtectMdlSystemAddress(pMdl, PAGE_EXECUTE_READWRITE);
290	#endif
291
292	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PAGE, pv, cb, pszTag);
293	if (pMemNt)
294	{
295	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC;
296	pMemNt->fAllocatedPagesForMdl = true;
297	pMemNt->cMdls = 1;
298	pMemNt->apMdls[0] = pMdl;
299	*ppMem = &pMemNt->Core;
300	return VINF_SUCCESS;
301	}
302	MmUnmapLockedPages(pv, pMdl);
303	}
304	}
305	__except(EXCEPTION_EXECUTE_HANDLER)
306	{
307	# ifdef LOG_ENABLED
308	NTSTATUS rcNt = GetExceptionCode();
309	Log(("rtR0MemObjNativeAllocLow: Exception Code %#x\n", rcNt));
310	# endif
311	/* nothing */
312	}
313	}
314	g_pfnrtMmFreePagesFromMdl(pMdl);
315	ExFreePool(pMdl);
316	}
317	}
318
319	/*
320	* Try allocate the memory and create an MDL for them so
321	* we can query the physical addresses and do mappings later
322	* without running into out-of-memory conditions and similar problems.
323	*/
324	void *pv;
325	if (g_pfnrtExAllocatePoolWithTag)
326	pv = g_pfnrtExAllocatePoolWithTag(NonPagedPool, cb, IPRT_NT_POOL_TAG);
327	else
328	pv = ExAllocatePool(NonPagedPool, cb);
329	if (pv)
330	{
331	PMDL pMdl = IoAllocateMdl(pv, (ULONG)cb, FALSE, FALSE, NULL);
332	if (pMdl)
333	{
334	MmBuildMdlForNonPagedPool(pMdl);
335	#ifdef RT_ARCH_AMD64
336	if (fExecutable)
337	MmProtectMdlSystemAddress(pMdl, PAGE_EXECUTE_READWRITE);
338	#endif
339
340	/*
341	* Create the IPRT memory object.
342	*/
343	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PAGE, pv, cb, pszTag);
344	if (pMemNt)
345	{
346	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_UNINITIALIZED_AT_ALLOC;
347	pMemNt->cMdls = 1;
348	pMemNt->apMdls[0] = pMdl;
349	*ppMem = &pMemNt->Core;
350	return VINF_SUCCESS;
351	}
352
353	rc = VERR_NO_MEMORY;
354	IoFreeMdl(pMdl);
355	}
356	ExFreePool(pv);
357	}
358	return rc;
359	}
360
361
362	/**
363	* Helper for rtR0MemObjNativeAllocLarge that verifies the result.
364	*/
365	static bool rtR0MemObjNtVerifyLargePageAlloc(PMDL pMdl, size_t cb, size_t cbLargePage)
366	{
367	if (MmGetMdlByteCount(pMdl) >= cb)
368	{
369	PPFN_NUMBER const paPfns = MmGetMdlPfnArray(pMdl);
370	size_t const cPagesPerLargePage = cbLargePage >> PAGE_SHIFT;
371	size_t const cLargePages = cb / cbLargePage;
372	size_t iPage = 0;
373	for (size_t iLargePage = 0; iLargePage < cLargePages; iLargePage++)
374	{
375	PFN_NUMBER Pfn = paPfns[iPage];
376	if (!(Pfn & (cbLargePage >> PAGE_SHIFT) - 1U))
377	{
378	for (size_t iSubPage = 1; iSubPage < cPagesPerLargePage; iSubPage++)
379	{
380	iPage++;
381	Pfn++;
382	if (paPfns[iPage] == Pfn)
383	{ /* likely */ }
384	else
385	{
386	Log(("rtR0MemObjNativeAllocLarge: Subpage %#zu in large page #%zu is not contiguous: %#x, expected %#x\n",
387	iSubPage, iLargePage, paPfns[iPage], Pfn));
388	return false;
389	}
390	}
391	}
392	else
393	{
394	Log(("rtR0MemObjNativeAllocLarge: Large page #%zu is misaligned: %#x, cbLargePage=%#zx\n",
395	iLargePage, Pfn, cbLargePage));
396	return false;
397	}
398	}
399	return true;
400	}
401	Log(("rtR0MemObjNativeAllocLarge: Got back too few pages: %#zx, requested %#zx\n", MmGetMdlByteCount(pMdl), cb));
402	return false;
403	}
404
405
406	DECLHIDDEN(int) rtR0MemObjNativeAllocLarge(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, size_t cbLargePage, uint32_t fFlags,
407	const char *pszTag)
408	{
409	/*
410	* Need the MmAllocatePagesForMdlEx function so we can specify flags.
411	*/
412	if ( g_uRtNtVersion >= RTNT_MAKE_VERSION(6,1) /* Windows 7+ */
413	&& g_pfnrtMmAllocatePagesForMdlEx
414	&& g_pfnrtMmFreePagesFromMdl
415	&& g_pfnrtMmMapLockedPagesSpecifyCache)
416	{
417	ULONG fNtFlags = MM_ALLOCATE_FULLY_REQUIRED /* W7+: Make it fail if we don't get all we ask for.*/
418	\| MM_ALLOCATE_REQUIRE_CONTIGUOUS_CHUNKS; /* W7+: The SkipBytes chunks must be physcially contiguous. */
419	if ((fFlags & RTMEMOBJ_ALLOC_LARGE_F_FAST) && g_uRtNtVersion >= RTNT_MAKE_VERSION(6, 2))
420	fNtFlags \|= MM_ALLOCATE_FAST_LARGE_PAGES; /* W8+: Don't try too hard, just fail if not enough handy. */
421
422	PHYSICAL_ADDRESS Zero;
423	Zero.QuadPart = 0;
424
425	PHYSICAL_ADDRESS HighAddr;
426	HighAddr.QuadPart = MAXLONGLONG;
427
428	PHYSICAL_ADDRESS Skip;
429	Skip.QuadPart = cbLargePage;
430
431	int rc;
432	PMDL const pMdl = g_pfnrtMmAllocatePagesForMdlEx(Zero, HighAddr, Skip, cb, MmCached, fNtFlags);
433	if (pMdl)
434	{
435	/* Verify the result. */
436	if (rtR0MemObjNtVerifyLargePageAlloc(pMdl, cb, cbLargePage))
437	{
438	/*
439	* Map the allocation into kernel space. Unless the memory is already mapped
440	* somewhere (seems to be actually), I guess it's unlikely that we'll get a
441	* large page aligned mapping back here...
442	*/
443	__try
444	{
445	void pv = g_pfnrtMmMapLockedPagesSpecifyCache(pMdl, KernelMode, MmCached, NULL / no base address */,
446	FALSE /* no bug check on failure */, NormalPagePriority);
447	if (pv)
448	{
449	/*
450	* Create the memory object.
451	*/
452	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PAGE, pv, cb, pszTag);
453	if (pMemNt)
454	{
455	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC;
456	pMemNt->fAllocatedPagesForMdl = true;
457	pMemNt->cMdls = 1;
458	pMemNt->apMdls[0] = pMdl;
459	*ppMem = &pMemNt->Core;
460	return VINF_SUCCESS;
461	}
462
463	MmUnmapLockedPages(pv, pMdl);
464	}
465	}
466	__except(EXCEPTION_EXECUTE_HANDLER)
467	{
468	#ifdef LOG_ENABLED
469	NTSTATUS rcNt = GetExceptionCode();
470	Log(("rtR0MemObjNativeAllocLarge: Exception Code %#x\n", rcNt));
471	#endif
472	/* nothing */
473	}
474	}
475
476	g_pfnrtMmFreePagesFromMdl(pMdl);
477	ExFreePool(pMdl);
478	rc = VERR_NO_MEMORY;
479	}
480	else
481	rc = fFlags & RTMEMOBJ_ALLOC_LARGE_F_FAST ? VERR_TRY_AGAIN : VERR_NO_MEMORY;
482	return rc;
483	}
484
485	return rtR0MemObjFallbackAllocLarge(ppMem, cb, cbLargePage, fFlags, pszTag);
486	}
487
488
489	DECLHIDDEN(int) rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
490	{
491	AssertMsgReturn(cb <= _1G, ("%#x\n", cb), VERR_OUT_OF_RANGE); /* for safe size_t -> ULONG */
492
493	/*
494	* Try see if we get lucky first...
495	* (We could probably just assume we're lucky on NT4.)
496	*/
497	int rc = rtR0MemObjNativeAllocPage(ppMem, cb, fExecutable, pszTag);
498	if (RT_SUCCESS(rc))
499	{
500	size_t iPage = cb >> PAGE_SHIFT;
501	while (iPage-- > 0)
502	if (rtR0MemObjNativeGetPagePhysAddr(*ppMem, iPage) >= _4G)
503	{
504	rc = VERR_NO_LOW_MEMORY;
505	break;
506	}
507	if (RT_SUCCESS(rc))
508	return rc;
509
510	/* The following ASSUMES that rtR0MemObjNativeAllocPage returns a completed object. */
511	RTR0MemObjFree(*ppMem, false);
512	*ppMem = NULL;
513	}
514
515	/*
516	* Use MmAllocatePagesForMdl to specify the range of physical addresses we wish to use.
517	*/
518	if ( g_pfnrtMmAllocatePagesForMdl
519	&& g_pfnrtMmFreePagesFromMdl
520	&& g_pfnrtMmMapLockedPagesSpecifyCache)
521	{
522	PHYSICAL_ADDRESS Zero;
523	Zero.QuadPart = 0;
524	PHYSICAL_ADDRESS HighAddr;
525	HighAddr.QuadPart = _4G - 1;
526	PMDL pMdl = g_pfnrtMmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
527	if (pMdl)
528	{
529	if (MmGetMdlByteCount(pMdl) >= cb)
530	{
531	__try
532	{
533	void pv = g_pfnrtMmMapLockedPagesSpecifyCache(pMdl, KernelMode, MmCached, NULL / no base address */,
534	FALSE /* no bug check on failure */, NormalPagePriority);
535	if (pv)
536	{
537	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_LOW, pv, cb, pszTag);
538	if (pMemNt)
539	{
540	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC;
541	pMemNt->fAllocatedPagesForMdl = true;
542	pMemNt->cMdls = 1;
543	pMemNt->apMdls[0] = pMdl;
544	*ppMem = &pMemNt->Core;
545	return VINF_SUCCESS;
546	}
547	MmUnmapLockedPages(pv, pMdl);
548	}
549	}
550	__except(EXCEPTION_EXECUTE_HANDLER)
551	{
552	# ifdef LOG_ENABLED
553	NTSTATUS rcNt = GetExceptionCode();
554	Log(("rtR0MemObjNativeAllocLow: Exception Code %#x\n", rcNt));
555	# endif
556	/* nothing */
557	}
558	}
559	g_pfnrtMmFreePagesFromMdl(pMdl);
560	ExFreePool(pMdl);
561	}
562	}
563
564	/*
565	* Fall back on contiguous memory...
566	*/
567	return rtR0MemObjNativeAllocCont(ppMem, cb, _4G - 1, fExecutable, pszTag);
568	}
569
570
571	/**
572	* Internal worker for rtR0MemObjNativeAllocCont(), rtR0MemObjNativeAllocPhys()
573	* and rtR0MemObjNativeAllocPhysNC() that takes a max physical address in addition
574	* to what rtR0MemObjNativeAllocCont() does.
575	*
576	* @returns IPRT status code.
577	* @param ppMem Where to store the pointer to the ring-0 memory object.
578	* @param cb The size.
579	* @param fExecutable Whether the mapping should be executable or not.
580	* @param PhysHighest The highest physical address for the pages in allocation.
581	* @param uAlignment The alignment of the physical memory to allocate.
582	* Supported values are PAGE_SIZE, _2M, _4M and _1G.
583	* @param pszTag Allocation tag used for statistics and such.
584	*/
585	static int rtR0MemObjNativeAllocContEx(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, RTHCPHYS PhysHighest,
586	size_t uAlignment, const char *pszTag)
587	{
588	AssertMsgReturn(cb <= _1G, ("%#x\n", cb), VERR_OUT_OF_RANGE); /* for safe size_t -> ULONG */
589	RT_NOREF1(fExecutable);
590
591	/*
592	* Allocate the memory and create an MDL for it.
593	*/
594	PHYSICAL_ADDRESS PhysAddrHighest;
595	PhysAddrHighest.QuadPart = PhysHighest;
596	void *pv;
597	if (g_pfnrtMmAllocateContiguousMemorySpecifyCache)
598	{
599	PHYSICAL_ADDRESS PhysAddrLowest, PhysAddrBoundary;
600	PhysAddrLowest.QuadPart = 0;
601	PhysAddrBoundary.QuadPart = (uAlignment == PAGE_SIZE) ? 0 : uAlignment;
602	pv = g_pfnrtMmAllocateContiguousMemorySpecifyCache(cb, PhysAddrLowest, PhysAddrHighest, PhysAddrBoundary, MmCached);
603	}
604	else if (uAlignment == PAGE_SIZE)
605	pv = MmAllocateContiguousMemory(cb, PhysAddrHighest);
606	else
607	return VERR_NOT_SUPPORTED;
608	if (!pv)
609	return VERR_NO_MEMORY;
610
611	PMDL pMdl = IoAllocateMdl(pv, (ULONG)cb, FALSE, FALSE, NULL);
612	if (pMdl)
613	{
614	MmBuildMdlForNonPagedPool(pMdl);
615	#ifdef RT_ARCH_AMD64
616	if (fExecutable)
617	MmProtectMdlSystemAddress(pMdl, PAGE_EXECUTE_READWRITE);
618	#endif
619
620	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_CONT, pv, cb, pszTag);
621	if (pMemNt)
622	{
623	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_UNINITIALIZED_AT_ALLOC;
624	pMemNt->Core.u.Cont.Phys = (RTHCPHYS)*MmGetMdlPfnArray(pMdl) << PAGE_SHIFT;
625	pMemNt->cMdls = 1;
626	pMemNt->apMdls[0] = pMdl;
627	*ppMem = &pMemNt->Core;
628	return VINF_SUCCESS;
629	}
630
631	IoFreeMdl(pMdl);
632	}
633	MmFreeContiguousMemory(pv);
634	return VERR_NO_MEMORY;
635	}
636
637
638	DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest,
639	bool fExecutable, const char *pszTag)
640	{
641	return rtR0MemObjNativeAllocContEx(ppMem, cb, fExecutable, PhysHighest, PAGE_SIZE /* alignment */, pszTag);
642	}
643
644
645	DECLHIDDEN(int) rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, size_t uAlignment,
646	const char *pszTag)
647	{
648	/*
649	* Try and see if we're lucky and get a contiguous chunk from MmAllocatePagesForMdl.
650	*
651	* This is preferable to using MmAllocateContiguousMemory because there are
652	* a few situations where the memory shouldn't be mapped, like for instance
653	* VT-x control memory. Since these are rather small allocations (one or
654	* two pages) MmAllocatePagesForMdl will probably be able to satisfy the
655	* request.
656	*
657	* If the allocation is big, the chances are probably not very good. The
658	* current limit is kind of random...
659	*/
660	if ( cb < _128K
661	&& uAlignment == PAGE_SIZE
662	&& g_pfnrtMmAllocatePagesForMdl
663	&& g_pfnrtMmFreePagesFromMdl)
664	{
665	PHYSICAL_ADDRESS Zero;
666	Zero.QuadPart = 0;
667	PHYSICAL_ADDRESS HighAddr;
668	HighAddr.QuadPart = PhysHighest == NIL_RTHCPHYS ? MAXLONGLONG : PhysHighest;
669	PMDL pMdl = g_pfnrtMmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
670	if (pMdl)
671	{
672	if (MmGetMdlByteCount(pMdl) >= cb)
673	{
674	PPFN_NUMBER paPfns = MmGetMdlPfnArray(pMdl);
675	PFN_NUMBER Pfn = paPfns[0] + 1;
676	const size_t cPages = cb >> PAGE_SHIFT;
677	size_t iPage;
678	for (iPage = 1; iPage < cPages; iPage++, Pfn++)
679	if (paPfns[iPage] != Pfn)
680	break;
681	if (iPage >= cPages)
682	{
683	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PHYS, NULL, cb, pszTag);
684	if (pMemNt)
685	{
686	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC;
687	pMemNt->Core.u.Phys.fAllocated = true;
688	pMemNt->Core.u.Phys.PhysBase = (RTHCPHYS)paPfns[0] << PAGE_SHIFT;
689	pMemNt->fAllocatedPagesForMdl = true;
690	pMemNt->cMdls = 1;
691	pMemNt->apMdls[0] = pMdl;
692	*ppMem = &pMemNt->Core;
693	return VINF_SUCCESS;
694	}
695	}
696	}
697	g_pfnrtMmFreePagesFromMdl(pMdl);
698	ExFreePool(pMdl);
699	}
700	}
701
702	return rtR0MemObjNativeAllocContEx(ppMem, cb, false, PhysHighest, uAlignment, pszTag);
703	}
704
705
706	DECLHIDDEN(int) rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
707	{
708	if (g_pfnrtMmAllocatePagesForMdl && g_pfnrtMmFreePagesFromMdl)
709	{
710	/** @todo use the Ex version with the fail-if-not-all-requested-pages flag
711	* when possible. */
712	PHYSICAL_ADDRESS Zero;
713	Zero.QuadPart = 0;
714	PHYSICAL_ADDRESS HighAddr;
715	HighAddr.QuadPart = PhysHighest == NIL_RTHCPHYS ? MAXLONGLONG : PhysHighest;
716	PMDL pMdl = g_pfnrtMmAllocatePagesForMdl(Zero, HighAddr, Zero, cb);
717	if (pMdl)
718	{
719	if (MmGetMdlByteCount(pMdl) >= cb)
720	{
721	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PHYS_NC, NULL, cb, pszTag);
722	if (pMemNt)
723	{
724	pMemNt->Core.fFlags \|= RTR0MEMOBJ_FLAGS_ZERO_AT_ALLOC;
725	pMemNt->fAllocatedPagesForMdl = true;
726	pMemNt->cMdls = 1;
727	pMemNt->apMdls[0] = pMdl;
728	*ppMem = &pMemNt->Core;
729	return VINF_SUCCESS;
730	}
731	}
732	g_pfnrtMmFreePagesFromMdl(pMdl);
733	ExFreePool(pMdl);
734	}
735	return VERR_NO_MEMORY;
736	}
737	return VERR_NOT_SUPPORTED;
738	}
739
740
741	DECLHIDDEN(int) rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb, uint32_t uCachePolicy,
742	const char *pszTag)
743	{
744	AssertReturn(uCachePolicy == RTMEM_CACHE_POLICY_DONT_CARE \|\| uCachePolicy == RTMEM_CACHE_POLICY_MMIO, VERR_NOT_SUPPORTED);
745
746	/*
747	* Validate the address range and create a descriptor for it.
748	*/
749	PFN_NUMBER Pfn = (PFN_NUMBER)(Phys >> PAGE_SHIFT);
750	if (((RTHCPHYS)Pfn << PAGE_SHIFT) != Phys)
751	return VERR_ADDRESS_TOO_BIG;
752
753	/*
754	* Create the IPRT memory object.
755	*/
756	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_PHYS, NULL, cb, pszTag);
757	if (pMemNt)
758	{
759	pMemNt->Core.u.Phys.PhysBase = Phys;
760	pMemNt->Core.u.Phys.fAllocated = false;
761	pMemNt->Core.u.Phys.uCachePolicy = uCachePolicy;
762	*ppMem = &pMemNt->Core;
763	return VINF_SUCCESS;
764	}
765	return VERR_NO_MEMORY;
766	}
767
768
769	/**
770	* Internal worker for locking down pages.
771	*
772	* @return IPRT status code.
773	*
774	* @param ppMem Where to store the memory object pointer.
775	* @param pv First page.
776	* @param cb Number of bytes.
777	* @param fAccess The desired access, a combination of RTMEM_PROT_READ
778	* and RTMEM_PROT_WRITE.
779	* @param R0Process The process \a pv and \a cb refers to.
780	* @param pszTag Allocation tag used for statistics and such.
781	*/
782	static int rtR0MemObjNtLock(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process,
783	const char *pszTag)
784	{
785	/*
786	* Calc the number of MDLs we need and allocate the memory object structure.
787	*/
788	size_t cMdls = cb / MAX_LOCK_MEM_SIZE;
789	if (cb % MAX_LOCK_MEM_SIZE)
790	cMdls++;
791	if (cMdls >= UINT32_MAX)
792	return VERR_OUT_OF_RANGE;
793	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(RT_UOFFSETOF_DYN(RTR0MEMOBJNT, apMdls[cMdls]),
794	RTR0MEMOBJTYPE_LOCK, pv, cb, pszTag);
795	if (!pMemNt)
796	return VERR_NO_MEMORY;
797
798	/*
799	* Loop locking down the sub parts of the memory.
800	*/
801	int rc = VINF_SUCCESS;
802	size_t cbTotal = 0;
803	uint8_t pb = (uint8_t )pv;
804	uint32_t iMdl;
805	for (iMdl = 0; iMdl < cMdls; iMdl++)
806	{
807	/*
808	* Calc the Mdl size and allocate it.
809	*/
810	size_t cbCur = cb - cbTotal;
811	if (cbCur > MAX_LOCK_MEM_SIZE)
812	cbCur = MAX_LOCK_MEM_SIZE;
813	AssertMsg(cbCur, ("cbCur: 0!\n"));
814	PMDL pMdl = IoAllocateMdl(pb, (ULONG)cbCur, FALSE, FALSE, NULL);
815	if (!pMdl)
816	{
817	rc = VERR_NO_MEMORY;
818	break;
819	}
820
821	/*
822	* Lock the pages.
823	*/
824	__try
825	{
826	MmProbeAndLockPages(pMdl,
827	R0Process == NIL_RTR0PROCESS ? KernelMode : UserMode,
828	fAccess == RTMEM_PROT_READ
829	? IoReadAccess
830	: fAccess == RTMEM_PROT_WRITE
831	? IoWriteAccess
832	: IoModifyAccess);
833
834	pMemNt->apMdls[iMdl] = pMdl;
835	pMemNt->cMdls++;
836	}
837	__except(EXCEPTION_EXECUTE_HANDLER)
838	{
839	IoFreeMdl(pMdl);
840	rc = VERR_LOCK_FAILED;
841	break;
842	}
843
844	if ( R0Process != NIL_RTR0PROCESS
845	&& g_pfnrtMmSecureVirtualMemory
846	&& g_pfnrtMmUnsecureVirtualMemory)
847	{
848	/* Make sure the user process can't change the allocation. */
849	pMemNt->pvSecureMem = g_pfnrtMmSecureVirtualMemory(pv, cb,
850	fAccess & RTMEM_PROT_WRITE
851	? PAGE_READWRITE
852	: PAGE_READONLY);
853	if (!pMemNt->pvSecureMem)
854	{
855	rc = VERR_NO_MEMORY;
856	break;
857	}
858	}
859
860	/* next */
861	cbTotal += cbCur;
862	pb += cbCur;
863	}
864	if (RT_SUCCESS(rc))
865	{
866	Assert(pMemNt->cMdls == cMdls);
867	pMemNt->Core.u.Lock.R0Process = R0Process;
868	*ppMem = &pMemNt->Core;
869	return rc;
870	}
871
872	/*
873	* We failed, perform cleanups.
874	*/
875	while (iMdl-- > 0)
876	{
877	MmUnlockPages(pMemNt->apMdls[iMdl]);
878	IoFreeMdl(pMemNt->apMdls[iMdl]);
879	pMemNt->apMdls[iMdl] = NULL;
880	}
881	if (pMemNt->pvSecureMem)
882	{
883	if (g_pfnrtMmUnsecureVirtualMemory)
884	g_pfnrtMmUnsecureVirtualMemory(pMemNt->pvSecureMem);
885	pMemNt->pvSecureMem = NULL;
886	}
887
888	rtR0MemObjDelete(&pMemNt->Core);
889	return rc;
890	}
891
892
893	DECLHIDDEN(int) rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess,
894	RTR0PROCESS R0Process, const char *pszTag)
895	{
896	AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
897	/* (Can use MmProbeAndLockProcessPages if we need to mess with other processes later.) */
898	return rtR0MemObjNtLock(ppMem, (void *)R3Ptr, cb, fAccess, R0Process, pszTag);
899	}
900
901
902	DECLHIDDEN(int) rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void pv, size_t cb, uint32_t fAccess, const char pszTag)
903	{
904	return rtR0MemObjNtLock(ppMem, pv, cb, fAccess, NIL_RTR0PROCESS, pszTag);
905	}
906
907
908	DECLHIDDEN(int) rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment,
909	const char *pszTag)
910	{
911	/*
912	* MmCreateSection(SEC_RESERVE) + MmMapViewInSystemSpace perhaps?
913	* Or MmAllocateMappingAddress?
914	*/
915	RT_NOREF(ppMem, pvFixed, cb, uAlignment, pszTag);
916	return VERR_NOT_SUPPORTED;
917	}
918
919
920	DECLHIDDEN(int) rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment,
921	RTR0PROCESS R0Process, const char *pszTag)
922	{
923	/*
924	* ZeCreateSection(SEC_RESERVE) + ZwMapViewOfSection perhaps?
925	*/
926	RT_NOREF(ppMem, R3PtrFixed, cb, uAlignment, R0Process, pszTag);
927	return VERR_NOT_SUPPORTED;
928	}
929
930
931	/**
932	* Internal worker for rtR0MemObjNativeMapKernel and rtR0MemObjNativeMapUser.
933	*
934	* @returns IPRT status code.
935	* @param ppMem Where to store the memory object for the mapping.
936	* @param pMemToMap The memory object to map.
937	* @param pvFixed Where to map it. (void *)-1 if anywhere is fine.
938	* @param uAlignment The alignment requirement for the mapping.
939	* @param fProt The desired page protection for the mapping.
940	* @param R0Process If NIL_RTR0PROCESS map into system (kernel) memory.
941	* If not nil, it's the current process.
942	* @param offSub Offset into @a pMemToMap to start mapping.
943	* @param cbSub The number of bytes to map from @a pMapToMem. 0 if
944	* we're to map everything. Non-zero if @a offSub is
945	* non-zero.
946	* @param pszTag Allocation tag used for statistics and such.
947	*/
948	static int rtR0MemObjNtMap(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment,
949	unsigned fProt, RTR0PROCESS R0Process, size_t offSub, size_t cbSub, const char *pszTag)
950	{
951	int rc = VERR_MAP_FAILED;
952
953	/*
954	* Check that the specified alignment is supported.
955	*/
956	if (uAlignment > PAGE_SIZE)
957	return VERR_NOT_SUPPORTED;
958
959	/*
960	* There are two basic cases here, either we've got an MDL and can
961	* map it using MmMapLockedPages, or we've got a contiguous physical
962	* range (MMIO most likely) and can use MmMapIoSpace.
963	*/
964	PRTR0MEMOBJNT pMemNtToMap = (PRTR0MEMOBJNT)pMemToMap;
965	if (pMemNtToMap->cMdls)
966	{
967	/* don't attempt map locked regions with more than one mdl. */
968	if (pMemNtToMap->cMdls != 1)
969	return VERR_NOT_SUPPORTED;
970
971	/* Need g_pfnrtMmMapLockedPagesSpecifyCache to map to a specific address. */
972	if (pvFixed != (void *)-1 && g_pfnrtMmMapLockedPagesSpecifyCache == NULL)
973	return VERR_NOT_SUPPORTED;
974
975	/* we can't map anything to the first page, sorry. */
976	if (pvFixed == 0)
977	return VERR_NOT_SUPPORTED;
978
979	/* only one system mapping for now - no time to figure out MDL restrictions right now. */
980	if ( pMemNtToMap->Core.uRel.Parent.cMappings
981	&& R0Process == NIL_RTR0PROCESS)
982	{
983	if (pMemNtToMap->Core.enmType != RTR0MEMOBJTYPE_PHYS_NC)
984	return VERR_NOT_SUPPORTED;
985	uint32_t iMapping = pMemNtToMap->Core.uRel.Parent.cMappings;
986	while (iMapping-- > 0)
987	{
988	PRTR0MEMOBJNT pMapping = (PRTR0MEMOBJNT)pMemNtToMap->Core.uRel.Parent.papMappings[iMapping];
989	if ( pMapping->Core.enmType != RTR0MEMOBJTYPE_MAPPING
990	\|\| pMapping->Core.u.Mapping.R0Process == NIL_RTR0PROCESS)
991	return VERR_NOT_SUPPORTED;
992	}
993	}
994
995	/* Create a partial MDL if this is a sub-range request. */
996	PMDL pMdl;
997	if (!offSub && !cbSub)
998	pMdl = pMemNtToMap->apMdls[0];
999	else
1000	{
1001	pMdl = IoAllocateMdl(NULL, (ULONG)cbSub, FALSE, FALSE, NULL);
1002	if (pMdl)
1003	IoBuildPartialMdl(pMemNtToMap->apMdls[0], pMdl,
1004	(uint8_t *)MmGetMdlVirtualAddress(pMemNtToMap->apMdls[0]) + offSub, (ULONG)cbSub);
1005	else
1006	{
1007	IoFreeMdl(pMdl);
1008	return VERR_NO_MEMORY;
1009	}
1010	}
1011
1012	__try
1013	{
1014	/** @todo uAlignment */
1015	/** @todo How to set the protection on the pages? */
1016	void *pv;
1017	if (g_pfnrtMmMapLockedPagesSpecifyCache)
1018	pv = g_pfnrtMmMapLockedPagesSpecifyCache(pMdl,
1019	R0Process == NIL_RTR0PROCESS ? KernelMode : UserMode,
1020	MmCached,
1021	pvFixed != (void *)-1 ? pvFixed : NULL,
1022	FALSE /* no bug check on failure */,
1023	NormalPagePriority);
1024	else
1025	pv = MmMapLockedPages(pMdl, R0Process == NIL_RTR0PROCESS ? KernelMode : UserMode);
1026	if (pv)
1027	{
1028	NOREF(fProt);
1029
1030	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew( !offSub && !cbSub
1031	? sizeof(*pMemNt) : RT_UOFFSETOF_DYN(RTR0MEMOBJNT, apMdls[1]),
1032	RTR0MEMOBJTYPE_MAPPING, pv, pMemNtToMap->Core.cb, pszTag);
1033	if (pMemNt)
1034	{
1035	pMemNt->Core.u.Mapping.R0Process = R0Process;
1036	if (!offSub && !cbSub)
1037	pMemNt->fSubMapping = false;
1038	else
1039	{
1040	pMemNt->apMdls[0] = pMdl;
1041	pMemNt->cMdls = 1;
1042	pMemNt->fSubMapping = true;
1043	}
1044
1045	*ppMem = &pMemNt->Core;
1046	return VINF_SUCCESS;
1047	}
1048
1049	rc = VERR_NO_MEMORY;
1050	MmUnmapLockedPages(pv, pMdl);
1051	}
1052	}
1053	__except(EXCEPTION_EXECUTE_HANDLER)
1054	{
1055	#ifdef LOG_ENABLED
1056	NTSTATUS rcNt = GetExceptionCode();
1057	Log(("rtR0MemObjNtMap: Exception Code %#x\n", rcNt));
1058	#endif
1059
1060	/* nothing */
1061	rc = VERR_MAP_FAILED;
1062	}
1063
1064	}
1065	else
1066	{
1067	AssertReturn( pMemNtToMap->Core.enmType == RTR0MEMOBJTYPE_PHYS
1068	&& !pMemNtToMap->Core.u.Phys.fAllocated, VERR_INTERNAL_ERROR);
1069
1070	/* cannot map phys mem to user space (yet). */
1071	if (R0Process != NIL_RTR0PROCESS)
1072	return VERR_NOT_SUPPORTED;
1073
1074	/* Cannot sub-mak these (yet). */
1075	AssertMsgReturn(!offSub && !cbSub, ("%#zx %#zx\n", offSub, cbSub), VERR_NOT_SUPPORTED);
1076
1077
1078	/** @todo uAlignment */
1079	/** @todo How to set the protection on the pages? */
1080	PHYSICAL_ADDRESS Phys;
1081	Phys.QuadPart = pMemNtToMap->Core.u.Phys.PhysBase;
1082	void *pv = MmMapIoSpace(Phys, pMemNtToMap->Core.cb,
1083	pMemNtToMap->Core.u.Phys.uCachePolicy == RTMEM_CACHE_POLICY_MMIO ? MmNonCached : MmCached);
1084	if (pv)
1085	{
1086	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)rtR0MemObjNew(sizeof(*pMemNt), RTR0MEMOBJTYPE_MAPPING, pv,
1087	pMemNtToMap->Core.cb, pszTag);
1088	if (pMemNt)
1089	{
1090	pMemNt->Core.u.Mapping.R0Process = R0Process;
1091	*ppMem = &pMemNt->Core;
1092	return VINF_SUCCESS;
1093	}
1094
1095	rc = VERR_NO_MEMORY;
1096	MmUnmapIoSpace(pv, pMemNtToMap->Core.cb);
1097	}
1098	}
1099
1100	NOREF(uAlignment); NOREF(fProt);
1101	return rc;
1102	}
1103
1104
1105	DECLHIDDEN(int) rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment,
1106	unsigned fProt, size_t offSub, size_t cbSub, const char *pszTag)
1107	{
1108	return rtR0MemObjNtMap(ppMem, pMemToMap, pvFixed, uAlignment, fProt, NIL_RTR0PROCESS, offSub, cbSub, pszTag);
1109	}
1110
1111
1112	DECLHIDDEN(int) rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment,
1113	unsigned fProt, RTR0PROCESS R0Process, size_t offSub, size_t cbSub, const char *pszTag)
1114	{
1115	AssertReturn(R0Process == RTR0ProcHandleSelf(), VERR_NOT_SUPPORTED);
1116	return rtR0MemObjNtMap(ppMem, pMemToMap, (void *)R3PtrFixed, uAlignment, fProt, R0Process, offSub, cbSub, pszTag);
1117	}
1118
1119
1120	DECLHIDDEN(int) rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
1121	{
1122	#if 0
1123	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)pMem;
1124	#endif
1125
1126	/*
1127	* Seems there are some issues with this MmProtectMdlSystemAddress API, so
1128	* this code isn't currently enabled until we've tested it with the verifier.
1129	*/
1130	#if 0
1131	/*
1132	* The API we've got requires a kernel mapping.
1133	*/
1134	if ( pMemNt->cMdls
1135	&& g_pfnrtMmProtectMdlSystemAddress
1136	&& (g_uRtNtMajorVer > 6 \|\| (g_uRtNtMajorVer == 6 && g_uRtNtMinorVer >= 1)) /* Windows 7 and later. */
1137	&& pMemNt->Core.pv != NULL
1138	&& ( pMemNt->Core.enmType == RTR0MEMOBJTYPE_PAGE
1139	\|\| pMemNt->Core.enmType == RTR0MEMOBJTYPE_LOW
1140	\|\| pMemNt->Core.enmType == RTR0MEMOBJTYPE_CONT
1141	\|\| ( pMemNt->Core.enmType == RTR0MEMOBJTYPE_LOCK
1142	&& pMemNt->Core.u.Lock.R0Process == NIL_RTPROCESS)
1143	\|\| ( pMemNt->Core.enmType == RTR0MEMOBJTYPE_MAPPING
1144	&& pMemNt->Core.u.Mapping.R0Process == NIL_RTPROCESS) ) )
1145	{
1146	/* Convert the protection. */
1147	LOCK_OPERATION enmLockOp;
1148	ULONG fAccess;
1149	switch (fProt)
1150	{
1151	case RTMEM_PROT_NONE:
1152	fAccess = PAGE_NOACCESS;
1153	enmLockOp = IoReadAccess;
1154	break;
1155	case RTMEM_PROT_READ:
1156	fAccess = PAGE_READONLY;
1157	enmLockOp = IoReadAccess;
1158	break;
1159	case RTMEM_PROT_WRITE:
1160	case RTMEM_PROT_WRITE \| RTMEM_PROT_READ:
1161	fAccess = PAGE_READWRITE;
1162	enmLockOp = IoModifyAccess;
1163	break;
1164	case RTMEM_PROT_EXEC:
1165	fAccess = PAGE_EXECUTE;
1166	enmLockOp = IoReadAccess;
1167	break;
1168	case RTMEM_PROT_EXEC \| RTMEM_PROT_READ:
1169	fAccess = PAGE_EXECUTE_READ;
1170	enmLockOp = IoReadAccess;
1171	break;
1172	case RTMEM_PROT_EXEC \| RTMEM_PROT_WRITE:
1173	case RTMEM_PROT_EXEC \| RTMEM_PROT_WRITE \| RTMEM_PROT_READ:
1174	fAccess = PAGE_EXECUTE_READWRITE;
1175	enmLockOp = IoModifyAccess;
1176	break;
1177	default:
1178	AssertFailedReturn(VERR_INVALID_FLAGS);
1179	}
1180
1181	NTSTATUS rcNt = STATUS_SUCCESS;
1182	# if 0 /** @todo test this against the verifier. */
1183	if (offSub == 0 && pMemNt->Core.cb == cbSub)
1184	{
1185	uint32_t iMdl = pMemNt->cMdls;
1186	while (iMdl-- > 0)
1187	{
1188	rcNt = g_pfnrtMmProtectMdlSystemAddress(pMemNt->apMdls[i], fAccess);
1189	if (!NT_SUCCESS(rcNt))
1190	break;
1191	}
1192	}
1193	else
1194	# endif
1195	{
1196	/*
1197	* We ASSUME the following here:
1198	* - MmProtectMdlSystemAddress can deal with nonpaged pool memory
1199	* - MmProtectMdlSystemAddress doesn't actually store anything in the MDL we pass it.
1200	* - We are not required to call MmProtectMdlSystemAddress with PAGE_READWRITE for the
1201	* exact same ranges prior to freeing them.
1202	*
1203	* So, we lock the pages temporarily, call the API and unlock them.
1204	*/
1205	uint8_t pbCur = (uint8_t )pMemNt->Core.pv + offSub;
1206	while (cbSub > 0 && NT_SUCCESS(rcNt))
1207	{
1208	size_t cbCur = cbSub;
1209	if (cbCur > MAX_LOCK_MEM_SIZE)
1210	cbCur = MAX_LOCK_MEM_SIZE;
1211	PMDL pMdl = IoAllocateMdl(pbCur, (ULONG)cbCur, FALSE, FALSE, NULL);
1212	if (pMdl)
1213	{
1214	__try
1215	{
1216	MmProbeAndLockPages(pMdl, KernelMode, enmLockOp);
1217	}
1218	__except(EXCEPTION_EXECUTE_HANDLER)
1219	{
1220	rcNt = GetExceptionCode();
1221	}
1222	if (NT_SUCCESS(rcNt))
1223	{
1224	rcNt = g_pfnrtMmProtectMdlSystemAddress(pMdl, fAccess);
1225	MmUnlockPages(pMdl);
1226	}
1227	IoFreeMdl(pMdl);
1228	}
1229	else
1230	rcNt = STATUS_NO_MEMORY;
1231	pbCur += cbCur;
1232	cbSub -= cbCur;
1233	}
1234	}
1235
1236	if (NT_SUCCESS(rcNt))
1237	return VINF_SUCCESS;
1238	return RTErrConvertFromNtStatus(rcNt);
1239	}
1240	#else
1241	RT_NOREF4(pMem, offSub, cbSub, fProt);
1242	#endif
1243
1244	return VERR_NOT_SUPPORTED;
1245	}
1246
1247
1248	DECLHIDDEN(RTHCPHYS) rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
1249	{
1250	PRTR0MEMOBJNT pMemNt = (PRTR0MEMOBJNT)pMem;
1251
1252	if (pMemNt->cMdls)
1253	{
1254	if (pMemNt->cMdls == 1)
1255	{
1256	PPFN_NUMBER paPfns = MmGetMdlPfnArray(pMemNt->apMdls[0]);
1257	return (RTHCPHYS)paPfns[iPage] << PAGE_SHIFT;
1258	}
1259
1260	size_t iMdl = iPage / (MAX_LOCK_MEM_SIZE >> PAGE_SHIFT);
1261	size_t iMdlPfn = iPage % (MAX_LOCK_MEM_SIZE >> PAGE_SHIFT);
1262	PPFN_NUMBER paPfns = MmGetMdlPfnArray(pMemNt->apMdls[iMdl]);
1263	return (RTHCPHYS)paPfns[iMdlPfn] << PAGE_SHIFT;
1264	}
1265
1266	switch (pMemNt->Core.enmType)
1267	{
1268	case RTR0MEMOBJTYPE_MAPPING:
1269	return rtR0MemObjNativeGetPagePhysAddr(pMemNt->Core.uRel.Child.pParent, iPage);
1270
1271	case RTR0MEMOBJTYPE_PHYS:
1272	return pMemNt->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);
1273
1274	case RTR0MEMOBJTYPE_PAGE:
1275	case RTR0MEMOBJTYPE_PHYS_NC:
1276	case RTR0MEMOBJTYPE_LOW:
1277	case RTR0MEMOBJTYPE_CONT:
1278	case RTR0MEMOBJTYPE_LOCK:
1279	default:
1280	AssertMsgFailed(("%d\n", pMemNt->Core.enmType));
1281	case RTR0MEMOBJTYPE_RES_VIRT:
1282	return NIL_RTHCPHYS;
1283	}
1284	}
1285

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

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

Download in other formats: