memobj-r0drv-freebsd.c@ 91483

Last change on this file since 91483 was 91483, checked in by vboxsync, 3 years ago
IPRT/memobj: Passing pszTag around...
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.4 KB

Line
1	/* $Id: memobj-r0drv-freebsd.c 91483 2021-09-30 00:19:19Z vboxsync $ */
2	/** @file
3	* IPRT - Ring-0 Memory Objects, FreeBSD.
4	*/
5
6	/*
7	* Contributed by knut st. osmundsen, Andriy Gapon.
8	*
9	* Copyright (C) 2007-2020 Oracle Corporation
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* The contents of this file may alternatively be used under the terms
20	* of the Common Development and Distribution License Version 1.0
21	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
22	* VirtualBox OSE distribution, in which case the provisions of the
23	* CDDL are applicable instead of those of the GPL.
24	*
25	* You may elect to license modified versions of this file under the
26	* terms and conditions of either the GPL or the CDDL or both.
27	* --------------------------------------------------------------------
28	*
29	* This code is based on:
30	*
31	* Copyright (c) 2007 knut st. osmundsen <bird-src-spam@anduin.net>
32	* Copyright (c) 2011 Andriy Gapon <avg@FreeBSD.org>
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	* Header Files *
59	*********************************************************************************************************************************/
60	#include "the-freebsd-kernel.h"
61
62	#include <iprt/memobj.h>
63	#include <iprt/mem.h>
64	#include <iprt/err.h>
65	#include <iprt/assert.h>
66	#include <iprt/log.h>
67	#include <iprt/param.h>
68	#include <iprt/process.h>
69	#include "internal/memobj.h"
70
71
72	/*********************************************************************************************************************************
73	* Structures and Typedefs *
74	*********************************************************************************************************************************/
75	/**
76	* The FreeBSD version of the memory object structure.
77	*/
78	typedef struct RTR0MEMOBJFREEBSD
79	{
80	/** The core structure. */
81	RTR0MEMOBJINTERNAL Core;
82	/** The VM object associated with the allocation. */
83	vm_object_t pObject;
84	} RTR0MEMOBJFREEBSD, *PRTR0MEMOBJFREEBSD;
85
86
87	MALLOC_DEFINE(M_IPRTMOBJ, "iprtmobj", "IPRT - R0MemObj");
88
89
90	/**
91	* Gets the virtual memory map the specified object is mapped into.
92	*
93	* @returns VM map handle on success, NULL if no map.
94	* @param pMem The memory object.
95	*/
96	static vm_map_t rtR0MemObjFreeBSDGetMap(PRTR0MEMOBJINTERNAL pMem)
97	{
98	switch (pMem->enmType)
99	{
100	case RTR0MEMOBJTYPE_PAGE:
101	case RTR0MEMOBJTYPE_LOW:
102	case RTR0MEMOBJTYPE_CONT:
103	return kernel_map;
104
105	case RTR0MEMOBJTYPE_PHYS:
106	case RTR0MEMOBJTYPE_PHYS_NC:
107	return NULL; /* pretend these have no mapping atm. */
108
109	case RTR0MEMOBJTYPE_LOCK:
110	return pMem->u.Lock.R0Process == NIL_RTR0PROCESS
111	? kernel_map
112	: &((struct proc *)pMem->u.Lock.R0Process)->p_vmspace->vm_map;
113
114	case RTR0MEMOBJTYPE_RES_VIRT:
115	return pMem->u.ResVirt.R0Process == NIL_RTR0PROCESS
116	? kernel_map
117	: &((struct proc *)pMem->u.ResVirt.R0Process)->p_vmspace->vm_map;
118
119	case RTR0MEMOBJTYPE_MAPPING:
120	return pMem->u.Mapping.R0Process == NIL_RTR0PROCESS
121	? kernel_map
122	: &((struct proc *)pMem->u.Mapping.R0Process)->p_vmspace->vm_map;
123
124	default:
125	return NULL;
126	}
127	}
128
129
130	DECLHIDDEN(int) rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
131	{
132	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)pMem;
133	int rc;
134
135	switch (pMemFreeBSD->Core.enmType)
136	{
137	case RTR0MEMOBJTYPE_PAGE:
138	case RTR0MEMOBJTYPE_LOW:
139	case RTR0MEMOBJTYPE_CONT:
140	rc = vm_map_remove(kernel_map,
141	(vm_offset_t)pMemFreeBSD->Core.pv,
142	(vm_offset_t)pMemFreeBSD->Core.pv + pMemFreeBSD->Core.cb);
143	AssertMsg(rc == KERN_SUCCESS, ("%#x", rc));
144	break;
145
146	case RTR0MEMOBJTYPE_LOCK:
147	{
148	vm_map_t pMap = kernel_map;
149
150	if (pMemFreeBSD->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
151	pMap = &((struct proc *)pMemFreeBSD->Core.u.Lock.R0Process)->p_vmspace->vm_map;
152
153	rc = vm_map_unwire(pMap,
154	(vm_offset_t)pMemFreeBSD->Core.pv,
155	(vm_offset_t)pMemFreeBSD->Core.pv + pMemFreeBSD->Core.cb,
156	VM_MAP_WIRE_SYSTEM \| VM_MAP_WIRE_NOHOLES);
157	AssertMsg(rc == KERN_SUCCESS, ("%#x", rc));
158	break;
159	}
160
161	case RTR0MEMOBJTYPE_RES_VIRT:
162	{
163	vm_map_t pMap = kernel_map;
164	if (pMemFreeBSD->Core.u.ResVirt.R0Process != NIL_RTR0PROCESS)
165	pMap = &((struct proc *)pMemFreeBSD->Core.u.ResVirt.R0Process)->p_vmspace->vm_map;
166	rc = vm_map_remove(pMap,
167	(vm_offset_t)pMemFreeBSD->Core.pv,
168	(vm_offset_t)pMemFreeBSD->Core.pv + pMemFreeBSD->Core.cb);
169	AssertMsg(rc == KERN_SUCCESS, ("%#x", rc));
170	break;
171	}
172
173	case RTR0MEMOBJTYPE_MAPPING:
174	{
175	vm_map_t pMap = kernel_map;
176
177	if (pMemFreeBSD->Core.u.Mapping.R0Process != NIL_RTR0PROCESS)
178	pMap = &((struct proc *)pMemFreeBSD->Core.u.Mapping.R0Process)->p_vmspace->vm_map;
179	rc = vm_map_remove(pMap,
180	(vm_offset_t)pMemFreeBSD->Core.pv,
181	(vm_offset_t)pMemFreeBSD->Core.pv + pMemFreeBSD->Core.cb);
182	AssertMsg(rc == KERN_SUCCESS, ("%#x", rc));
183	break;
184	}
185
186	case RTR0MEMOBJTYPE_PHYS:
187	case RTR0MEMOBJTYPE_PHYS_NC:
188	{
189	VM_OBJECT_WLOCK(pMemFreeBSD->pObject);
190	vm_page_t pPage = vm_page_find_least(pMemFreeBSD->pObject, 0);
191	#if __FreeBSD_version < 1000000
192	vm_page_lock_queues();
193	#endif
194	for (vm_page_t pPage = vm_page_find_least(pMemFreeBSD->pObject, 0);
195	pPage != NULL;
196	pPage = vm_page_next(pPage))
197	{
198	vm_page_unwire(pPage, 0);
199	}
200	#if __FreeBSD_version < 1000000
201	vm_page_unlock_queues();
202	#endif
203	VM_OBJECT_WUNLOCK(pMemFreeBSD->pObject);
204	vm_object_deallocate(pMemFreeBSD->pObject);
205	break;
206	}
207
208	default:
209	AssertMsgFailed(("enmType=%d\n", pMemFreeBSD->Core.enmType));
210	return VERR_INTERNAL_ERROR;
211	}
212
213	return VINF_SUCCESS;
214	}
215
216
217	static vm_page_t rtR0MemObjFreeBSDContigPhysAllocHelper(vm_object_t pObject, vm_pindex_t iPIndex,
218	u_long cPages, vm_paddr_t VmPhysAddrHigh,
219	u_long uAlignment, bool fWire)
220	{
221	vm_page_t pPages;
222	int cTries = 0;
223
224	#if __FreeBSD_version > 1000000
225	int fFlags = VM_ALLOC_INTERRUPT \| VM_ALLOC_NOBUSY;
226	if (fWire)
227	fFlags \|= VM_ALLOC_WIRED;
228
229	while (cTries <= 1)
230	{
231	VM_OBJECT_WLOCK(pObject);
232	pPages = vm_page_alloc_contig(pObject, iPIndex, fFlags, cPages, 0,
233	VmPhysAddrHigh, uAlignment, 0, VM_MEMATTR_DEFAULT);
234	VM_OBJECT_WUNLOCK(pObject);
235	if (pPages)
236	break;
237	#if __FreeBSD_version >= 1100092
238	if (!vm_page_reclaim_contig(cTries, cPages, 0, VmPhysAddrHigh, PAGE_SIZE, 0))
239	break;
240	#else
241	vm_pageout_grow_cache(cTries, 0, VmPhysAddrHigh);
242	#endif
243	cTries++;
244	}
245
246	return pPages;
247	#else
248	while (cTries <= 1)
249	{
250	pPages = vm_phys_alloc_contig(cPages, 0, VmPhysAddrHigh, uAlignment, 0);
251	if (pPages)
252	break;
253	vm_contig_grow_cache(cTries, 0, VmPhysAddrHigh);
254	cTries++;
255	}
256
257	if (!pPages)
258	return pPages;
259	VM_OBJECT_WLOCK(pObject);
260	for (vm_pindex_t iPage = 0; iPage < cPages; iPage++)
261	{
262	vm_page_t pPage = pPages + iPage;
263	vm_page_insert(pPage, pObject, iPIndex + iPage);
264	pPage->valid = VM_PAGE_BITS_ALL;
265	if (fWire)
266	{
267	pPage->wire_count = 1;
268	atomic_add_int(&cnt.v_wire_count, 1);
269	}
270	}
271	VM_OBJECT_WUNLOCK(pObject);
272	return pPages;
273	#endif
274	}
275
276	static int rtR0MemObjFreeBSDPhysAllocHelper(vm_object_t pObject, u_long cPages,
277	vm_paddr_t VmPhysAddrHigh, u_long uAlignment,
278	bool fContiguous, bool fWire, int rcNoMem)
279	{
280	if (fContiguous)
281	{
282	if (rtR0MemObjFreeBSDContigPhysAllocHelper(pObject, 0, cPages, VmPhysAddrHigh,
283	uAlignment, fWire) != NULL)
284	return VINF_SUCCESS;
285	return rcNoMem;
286	}
287
288	for (vm_pindex_t iPage = 0; iPage < cPages; iPage++)
289	{
290	vm_page_t pPage = rtR0MemObjFreeBSDContigPhysAllocHelper(pObject, iPage, 1, VmPhysAddrHigh,
291	uAlignment, fWire);
292	if (!pPage)
293	{
294	/* Free all allocated pages */
295	VM_OBJECT_WLOCK(pObject);
296	while (iPage-- > 0)
297	{
298	pPage = vm_page_lookup(pObject, iPage);
299	#if __FreeBSD_version < 1000000
300	vm_page_lock_queues();
301	#endif
302	if (fWire)
303	vm_page_unwire(pPage, 0);
304	vm_page_free(pPage);
305	#if __FreeBSD_version < 1000000
306	vm_page_unlock_queues();
307	#endif
308	}
309	VM_OBJECT_WUNLOCK(pObject);
310	return rcNoMem;
311	}
312	}
313	return VINF_SUCCESS;
314	}
315
316	static int rtR0MemObjFreeBSDAllocHelper(PRTR0MEMOBJFREEBSD pMemFreeBSD, bool fExecutable,
317	vm_paddr_t VmPhysAddrHigh, bool fContiguous, int rcNoMem)
318	{
319	vm_offset_t MapAddress = vm_map_min(kernel_map);
320	size_t cPages = atop(pMemFreeBSD->Core.cb);
321	int rc;
322
323	pMemFreeBSD->pObject = vm_object_allocate(OBJT_PHYS, cPages);
324
325	/* No additional object reference for auto-deallocation upon unmapping. */
326	#if __FreeBSD_version >= 1000055
327	rc = vm_map_find(kernel_map, pMemFreeBSD->pObject, 0,
328	&MapAddress, pMemFreeBSD->Core.cb, 0, VMFS_ANY_SPACE,
329	fExecutable ? VM_PROT_ALL : VM_PROT_RW, VM_PROT_ALL, 0);
330	#else
331	rc = vm_map_find(kernel_map, pMemFreeBSD->pObject, 0,
332	&MapAddress, pMemFreeBSD->Core.cb, VMFS_ANY_SPACE,
333	fExecutable ? VM_PROT_ALL : VM_PROT_RW, VM_PROT_ALL, 0);
334	#endif
335
336	if (rc == KERN_SUCCESS)
337	{
338	rc = rtR0MemObjFreeBSDPhysAllocHelper(pMemFreeBSD->pObject, cPages,
339	VmPhysAddrHigh, PAGE_SIZE, fContiguous,
340	false, rcNoMem);
341	if (RT_SUCCESS(rc))
342	{
343	vm_map_wire(kernel_map, MapAddress, MapAddress + pMemFreeBSD->Core.cb,
344	VM_MAP_WIRE_SYSTEM \| VM_MAP_WIRE_NOHOLES);
345
346	/* Store start address */
347	pMemFreeBSD->Core.pv = (void *)MapAddress;
348	return VINF_SUCCESS;
349	}
350
351	vm_map_remove(kernel_map, MapAddress, MapAddress + pMemFreeBSD->Core.cb);
352	}
353	else
354	{
355	rc = rcNoMem; /** @todo fix translation (borrow from darwin) */
356	vm_object_deallocate(pMemFreeBSD->pObject);
357	}
358
359	rtR0MemObjDelete(&pMemFreeBSD->Core);
360	return rc;
361	}
362
363
364	DECLHIDDEN(int) rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
365	{
366	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_PAGE,
367	NULL, cb, pszTag);
368	if (!pMemFreeBSD)
369	return VERR_NO_MEMORY;
370
371	int rc = rtR0MemObjFreeBSDAllocHelper(pMemFreeBSD, fExecutable, ~(vm_paddr_t)0, false, VERR_NO_MEMORY);
372	if (RT_FAILURE(rc))
373	{
374	rtR0MemObjDelete(&pMemFreeBSD->Core);
375	return rc;
376	}
377
378	*ppMem = &pMemFreeBSD->Core;
379	return rc;
380	}
381
382
383	DECLHIDDEN(int) rtR0MemObjNativeAllocLarge(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, size_t cbLargePage, uint32_t fFlags,
384	const char *pszTag)
385	{
386	return rtR0MemObjFallbackAllocLarge(ppMem, cb, cbLargePage, fFlags, pszTag);
387	}
388
389
390	DECLHIDDEN(int) rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
391	{
392	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_LOW, NULL, cb, pszTag);
393	if (!pMemFreeBSD)
394	return VERR_NO_MEMORY;
395
396	int rc = rtR0MemObjFreeBSDAllocHelper(pMemFreeBSD, fExecutable, _4G - 1, false, VERR_NO_LOW_MEMORY);
397	if (RT_FAILURE(rc))
398	{
399	rtR0MemObjDelete(&pMemFreeBSD->Core);
400	return rc;
401	}
402
403	*ppMem = &pMemFreeBSD->Core;
404	return rc;
405	}
406
407
408	DECLHIDDEN(int) rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
409	{
410	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_CONT,
411	NULL, cb, pszTag);
412	if (!pMemFreeBSD)
413	return VERR_NO_MEMORY;
414
415	int rc = rtR0MemObjFreeBSDAllocHelper(pMemFreeBSD, fExecutable, _4G - 1, true, VERR_NO_CONT_MEMORY);
416	if (RT_FAILURE(rc))
417	{
418	rtR0MemObjDelete(&pMemFreeBSD->Core);
419	return rc;
420	}
421
422	pMemFreeBSD->Core.u.Cont.Phys = vtophys(pMemFreeBSD->Core.pv);
423	*ppMem = &pMemFreeBSD->Core;
424	return rc;
425	}
426
427
428	static int rtR0MemObjFreeBSDAllocPhysPages(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJTYPE enmType, size_t cb, RTHCPHYS PhysHighest,
429	size_t uAlignment, bool fContiguous, int rcNoMem, const char *pszTag)
430	{
431	uint32_t cPages = atop(cb);
432	vm_paddr_t VmPhysAddrHigh;
433
434	/* create the object. */
435	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), enmType, NULL, cb, pszTag);
436	if (!pMemFreeBSD)
437	return VERR_NO_MEMORY;
438
439	pMemFreeBSD->pObject = vm_object_allocate(OBJT_PHYS, atop(cb));
440
441	if (PhysHighest != NIL_RTHCPHYS)
442	VmPhysAddrHigh = PhysHighest;
443	else
444	VmPhysAddrHigh = ~(vm_paddr_t)0;
445
446	int rc = rtR0MemObjFreeBSDPhysAllocHelper(pMemFreeBSD->pObject, cPages, VmPhysAddrHigh,
447	uAlignment, fContiguous, true, rcNoMem);
448	if (RT_SUCCESS(rc))
449	{
450	if (fContiguous)
451	{
452	Assert(enmType == RTR0MEMOBJTYPE_PHYS);
453	VM_OBJECT_WLOCK(pMemFreeBSD->pObject);
454	pMemFreeBSD->Core.u.Phys.PhysBase = VM_PAGE_TO_PHYS(vm_page_find_least(pMemFreeBSD->pObject, 0));
455	VM_OBJECT_WUNLOCK(pMemFreeBSD->pObject);
456	pMemFreeBSD->Core.u.Phys.fAllocated = true;
457	}
458
459	*ppMem = &pMemFreeBSD->Core;
460	}
461	else
462	{
463	vm_object_deallocate(pMemFreeBSD->pObject);
464	rtR0MemObjDelete(&pMemFreeBSD->Core);
465	}
466
467	return rc;
468	}
469
470
471	DECLHIDDEN(int) rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, size_t uAlignment,
472	const char *pszTag)
473	{
474	return rtR0MemObjFreeBSDAllocPhysPages(ppMem, RTR0MEMOBJTYPE_PHYS, cb, PhysHighest, uAlignment, true, VERR_NO_MEMORY, pszTag);
475	}
476
477
478	DECLHIDDEN(int) rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
479	{
480	return rtR0MemObjFreeBSDAllocPhysPages(ppMem, RTR0MEMOBJTYPE_PHYS_NC, cb, PhysHighest, PAGE_SIZE, false,
481	VERR_NO_PHYS_MEMORY, pszTag);
482	}
483
484
485	DECLHIDDEN(int) rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb, uint32_t uCachePolicy,
486	const char *pszTag)
487	{
488	AssertReturn(uCachePolicy == RTMEM_CACHE_POLICY_DONT_CARE, VERR_NOT_SUPPORTED);
489
490	/* create the object. */
491	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_PHYS,
492	NULL, cb, pszTag);
493	if (!pMemFreeBSD)
494	return VERR_NO_MEMORY;
495
496	/* there is no allocation here, it needs to be mapped somewhere first. */
497	pMemFreeBSD->Core.u.Phys.fAllocated = false;
498	pMemFreeBSD->Core.u.Phys.PhysBase = Phys;
499	pMemFreeBSD->Core.u.Phys.uCachePolicy = uCachePolicy;
500	*ppMem = &pMemFreeBSD->Core;
501	return VINF_SUCCESS;
502	}
503
504
505	/**
506	* Worker locking the memory in either kernel or user maps.
507	*/
508	static int rtR0MemObjNativeLockInMap(PPRTR0MEMOBJINTERNAL ppMem, vm_map_t pVmMap,
509	vm_offset_t AddrStart, size_t cb, uint32_t fAccess,
510	RTR0PROCESS R0Process, int fFlags, const char *pszTag)
511	{
512	int rc;
513	NOREF(fAccess);
514
515	/* create the object. */
516	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_LOCK,
517	(void *)AddrStart, cb, pszTag);
518	if (!pMemFreeBSD)
519	return VERR_NO_MEMORY;
520
521	/*
522	* We could've used vslock here, but we don't wish to be subject to
523	* resource usage restrictions, so we'll call vm_map_wire directly.
524	*/
525	rc = vm_map_wire(pVmMap, /* the map */
526	AddrStart, /* start */
527	AddrStart + cb, /* end */
528	fFlags); /* flags */
529	if (rc == KERN_SUCCESS)
530	{
531	pMemFreeBSD->Core.u.Lock.R0Process = R0Process;
532	*ppMem = &pMemFreeBSD->Core;
533	return VINF_SUCCESS;
534	}
535	rtR0MemObjDelete(&pMemFreeBSD->Core);
536	return VERR_NO_MEMORY;/** @todo fix mach -> vbox error conversion for freebsd. */
537	}
538
539
540	DECLHIDDEN(int) rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess,
541	RTR0PROCESS R0Process, const char *pszTag)
542	{
543	return rtR0MemObjNativeLockInMap(ppMem,
544	&((struct proc *)R0Process)->p_vmspace->vm_map,
545	(vm_offset_t)R3Ptr,
546	cb,
547	fAccess,
548	R0Process,
549	VM_MAP_WIRE_USER \| VM_MAP_WIRE_NOHOLES,
550	pszTag);
551	}
552
553
554	DECLHIDDEN(int) rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void pv, size_t cb, uint32_t fAccess, const char pszTag)
555	{
556	return rtR0MemObjNativeLockInMap(ppMem,
557	kernel_map,
558	(vm_offset_t)pv,
559	cb,
560	fAccess,
561	NIL_RTR0PROCESS,
562	VM_MAP_WIRE_SYSTEM \| VM_MAP_WIRE_NOHOLES,
563	pszTag);
564	}
565
566
567	/**
568	* Worker for the two virtual address space reservers.
569	*
570	* We're leaning on the examples provided by mmap and vm_mmap in vm_mmap.c here.
571	*/
572	static int rtR0MemObjNativeReserveInMap(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment,
573	RTR0PROCESS R0Process, vm_map_t pMap, const char *pszTag)
574	{
575	int rc;
576
577	/*
578	* The pvFixed address range must be within the VM space when specified.
579	*/
580	if ( pvFixed != (void *)-1
581	&& ( (vm_offset_t)pvFixed < vm_map_min(pMap)
582	\|\| (vm_offset_t)pvFixed + cb > vm_map_max(pMap)))
583	return VERR_INVALID_PARAMETER;
584
585	/*
586	* Check that the specified alignment is supported.
587	*/
588	if (uAlignment > PAGE_SIZE)
589	return VERR_NOT_SUPPORTED;
590
591	/*
592	* Create the object.
593	*/
594	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD), RTR0MEMOBJTYPE_RES_VIRT,
595	NULL, cb, pszTag);
596	if (!pMemFreeBSD)
597	return VERR_NO_MEMORY;
598
599	vm_offset_t MapAddress = pvFixed != (void *)-1
600	? (vm_offset_t)pvFixed
601	: vm_map_min(pMap);
602	if (pvFixed != (void *)-1)
603	vm_map_remove(pMap,
604	MapAddress,
605	MapAddress + cb);
606
607	rc = vm_map_find(pMap, /* map */
608	NULL, /* object */
609	0, /* offset */
610	&MapAddress, /* addr (IN/OUT) */
611	cb, /* length */
612	#if __FreeBSD_version >= 1000055
613	0, /* max addr */
614	#endif
615	pvFixed == (void *)-1 ? VMFS_ANY_SPACE : VMFS_NO_SPACE,
616	/* find_space */
617	VM_PROT_NONE, /* protection */
618	VM_PROT_ALL, /* max(_prot) ?? */
619	0); /* cow (copy-on-write) */
620	if (rc == KERN_SUCCESS)
621	{
622	if (R0Process != NIL_RTR0PROCESS)
623	{
624	rc = vm_map_inherit(pMap,
625	MapAddress,
626	MapAddress + cb,
627	VM_INHERIT_SHARE);
628	AssertMsg(rc == KERN_SUCCESS, ("%#x\n", rc));
629	}
630	pMemFreeBSD->Core.pv = (void *)MapAddress;
631	pMemFreeBSD->Core.u.ResVirt.R0Process = R0Process;
632	*ppMem = &pMemFreeBSD->Core;
633	return VINF_SUCCESS;
634	}
635
636	rc = VERR_NO_MEMORY; /** @todo fix translation (borrow from darwin) */
637	rtR0MemObjDelete(&pMemFreeBSD->Core);
638	return rc;
639
640	}
641
642
643	DECLHIDDEN(int) rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment,
644	const char *pszTag)
645	{
646	return rtR0MemObjNativeReserveInMap(ppMem, pvFixed, cb, uAlignment, NIL_RTR0PROCESS, kernel_map, pszTag);
647	}
648
649
650	DECLHIDDEN(int) rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment,
651	RTR0PROCESS R0Process, const char *pszTag)
652	{
653	return rtR0MemObjNativeReserveInMap(ppMem, (void *)R3PtrFixed, cb, uAlignment, R0Process,
654	&((struct proc *)R0Process)->p_vmspace->vm_map, pszTag);
655	}
656
657
658	DECLHIDDEN(int) rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment,
659	unsigned fProt, size_t offSub, size_t cbSub, const char *pszTag)
660	{
661	// AssertMsgReturn(!offSub && !cbSub, ("%#x %#x\n", offSub, cbSub), VERR_NOT_SUPPORTED);
662	AssertMsgReturn(pvFixed == (void *)-1, ("%p\n", pvFixed), VERR_NOT_SUPPORTED);
663
664	/*
665	* Check that the specified alignment is supported.
666	*/
667	if (uAlignment > PAGE_SIZE)
668	return VERR_NOT_SUPPORTED;
669	Assert(!offSub \|\| cbSub);
670
671	int rc;
672	PRTR0MEMOBJFREEBSD pMemToMapFreeBSD = (PRTR0MEMOBJFREEBSD)pMemToMap;
673
674	/* calc protection */
675	vm_prot_t ProtectionFlags = 0;
676	if ((fProt & RTMEM_PROT_NONE) == RTMEM_PROT_NONE)
677	ProtectionFlags = VM_PROT_NONE;
678	if ((fProt & RTMEM_PROT_READ) == RTMEM_PROT_READ)
679	ProtectionFlags \|= VM_PROT_READ;
680	if ((fProt & RTMEM_PROT_WRITE) == RTMEM_PROT_WRITE)
681	ProtectionFlags \|= VM_PROT_WRITE;
682	if ((fProt & RTMEM_PROT_EXEC) == RTMEM_PROT_EXEC)
683	ProtectionFlags \|= VM_PROT_EXECUTE;
684
685	vm_offset_t Addr = vm_map_min(kernel_map);
686	if (cbSub == 0)
687	cbSub = pMemToMap->cb - offSub;
688
689	vm_object_reference(pMemToMapFreeBSD->pObject);
690	rc = vm_map_find(kernel_map, /* Map to insert the object in */
691	pMemToMapFreeBSD->pObject, /* Object to map */
692	offSub, /* Start offset in the object */
693	&Addr, /* Start address IN/OUT */
694	cbSub, /* Size of the mapping */
695	#if __FreeBSD_version >= 1000055
696	0, /* Upper bound of mapping */
697	#endif
698	VMFS_ANY_SPACE, /* Whether a suitable address should be searched for first */
699	ProtectionFlags, /* protection flags */
700	VM_PROT_ALL, /* Maximum protection flags */
701	0); /* copy-on-write and similar flags */
702
703	if (rc == KERN_SUCCESS)
704	{
705	rc = vm_map_wire(kernel_map, Addr, Addr + cbSub, VM_MAP_WIRE_SYSTEM \| VM_MAP_WIRE_NOHOLES);
706	AssertMsg(rc == KERN_SUCCESS, ("%#x\n", rc));
707
708	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(RTR0MEMOBJFREEBSD), RTR0MEMOBJTYPE_MAPPING,
709	(void *)Addr, cbSub, pszTag);
710	if (pMemFreeBSD)
711	{
712	Assert((vm_offset_t)pMemFreeBSD->Core.pv == Addr);
713	pMemFreeBSD->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
714	*ppMem = &pMemFreeBSD->Core;
715	return VINF_SUCCESS;
716	}
717	rc = vm_map_remove(kernel_map, Addr, Addr + cbSub);
718	AssertMsg(rc == KERN_SUCCESS, ("Deleting mapping failed\n"));
719	}
720	else
721	vm_object_deallocate(pMemToMapFreeBSD->pObject);
722
723	return VERR_NO_MEMORY;
724	}
725
726
727	DECLHIDDEN(int) rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment,
728	unsigned fProt, RTR0PROCESS R0Process, size_t offSub, size_t cbSub, const char *pszTag)
729	{
730	/*
731	* Check for unsupported stuff.
732	*/
733	AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
734	if (uAlignment > PAGE_SIZE)
735	return VERR_NOT_SUPPORTED;
736	Assert(!offSub \|\| cbSub);
737
738	int rc;
739	PRTR0MEMOBJFREEBSD pMemToMapFreeBSD = (PRTR0MEMOBJFREEBSD)pMemToMap;
740	struct proc pProc = (struct proc )R0Process;
741	struct vm_map *pProcMap = &pProc->p_vmspace->vm_map;
742
743	/* calc protection */
744	vm_prot_t ProtectionFlags = 0;
745	if ((fProt & RTMEM_PROT_NONE) == RTMEM_PROT_NONE)
746	ProtectionFlags = VM_PROT_NONE;
747	if ((fProt & RTMEM_PROT_READ) == RTMEM_PROT_READ)
748	ProtectionFlags \|= VM_PROT_READ;
749	if ((fProt & RTMEM_PROT_WRITE) == RTMEM_PROT_WRITE)
750	ProtectionFlags \|= VM_PROT_WRITE;
751	if ((fProt & RTMEM_PROT_EXEC) == RTMEM_PROT_EXEC)
752	ProtectionFlags \|= VM_PROT_EXECUTE;
753
754	/* calc mapping address */
755	vm_offset_t AddrR3;
756	if (R3PtrFixed == (RTR3PTR)-1)
757	{
758	/** @todo is this needed?. */
759	PROC_LOCK(pProc);
760	AddrR3 = round_page((vm_offset_t)pProc->p_vmspace->vm_daddr + MY_LIM_MAX_PROC(pProc, RLIMIT_DATA));
761	PROC_UNLOCK(pProc);
762	}
763	else
764	AddrR3 = (vm_offset_t)R3PtrFixed;
765
766	if (cbSub == 0)
767	cbSub = pMemToMap->cb - offSub;
768
769	/* Insert the pObject in the map. */
770	vm_object_reference(pMemToMapFreeBSD->pObject);
771	rc = vm_map_find(pProcMap, /* Map to insert the object in */
772	pMemToMapFreeBSD->pObject, /* Object to map */
773	offSub, /* Start offset in the object */
774	&AddrR3, /* Start address IN/OUT */
775	cbSub, /* Size of the mapping */
776	#if __FreeBSD_version >= 1000055
777	0, /* Upper bound of the mapping */
778	#endif
779	R3PtrFixed == (RTR3PTR)-1 ? VMFS_ANY_SPACE : VMFS_NO_SPACE,
780	/* Whether a suitable address should be searched for first */
781	ProtectionFlags, /* protection flags */
782	VM_PROT_ALL, /* Maximum protection flags */
783	0); /* copy-on-write and similar flags */
784
785	if (rc == KERN_SUCCESS)
786	{
787	rc = vm_map_wire(pProcMap, AddrR3, AddrR3 + pMemToMap->cb, VM_MAP_WIRE_USER\|VM_MAP_WIRE_NOHOLES);
788	AssertMsg(rc == KERN_SUCCESS, ("%#x\n", rc));
789
790	rc = vm_map_inherit(pProcMap, AddrR3, AddrR3 + pMemToMap->cb, VM_INHERIT_SHARE);
791	AssertMsg(rc == KERN_SUCCESS, ("%#x\n", rc));
792
793	/*
794	* Create a mapping object for it.
795	*/
796	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(RTR0MEMOBJFREEBSD), RTR0MEMOBJTYPE_MAPPING,
797	(void *)AddrR3, pMemToMap->cb, pszTag);
798	if (pMemFreeBSD)
799	{
800	Assert((vm_offset_t)pMemFreeBSD->Core.pv == AddrR3);
801	pMemFreeBSD->Core.u.Mapping.R0Process = R0Process;
802	*ppMem = &pMemFreeBSD->Core;
803	return VINF_SUCCESS;
804	}
805
806	rc = vm_map_remove(pProcMap, AddrR3, AddrR3 + pMemToMap->cb);
807	AssertMsg(rc == KERN_SUCCESS, ("Deleting mapping failed\n"));
808	}
809	else
810	vm_object_deallocate(pMemToMapFreeBSD->pObject);
811
812	return VERR_NO_MEMORY;
813	}
814
815
816	DECLHIDDEN(int) rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
817	{
818	vm_prot_t ProtectionFlags = 0;
819	vm_offset_t AddrStart = (uintptr_t)pMem->pv + offSub;
820	vm_offset_t AddrEnd = AddrStart + cbSub;
821	vm_map_t pVmMap = rtR0MemObjFreeBSDGetMap(pMem);
822
823	if (!pVmMap)
824	return VERR_NOT_SUPPORTED;
825
826	if ((fProt & RTMEM_PROT_NONE) == RTMEM_PROT_NONE)
827	ProtectionFlags = VM_PROT_NONE;
828	if ((fProt & RTMEM_PROT_READ) == RTMEM_PROT_READ)
829	ProtectionFlags \|= VM_PROT_READ;
830	if ((fProt & RTMEM_PROT_WRITE) == RTMEM_PROT_WRITE)
831	ProtectionFlags \|= VM_PROT_WRITE;
832	if ((fProt & RTMEM_PROT_EXEC) == RTMEM_PROT_EXEC)
833	ProtectionFlags \|= VM_PROT_EXECUTE;
834
835	int krc = vm_map_protect(pVmMap, AddrStart, AddrEnd, ProtectionFlags, FALSE);
836	if (krc == KERN_SUCCESS)
837	return VINF_SUCCESS;
838
839	return VERR_NOT_SUPPORTED;
840	}
841
842
843	DECLHIDDEN(RTHCPHYS) rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
844	{
845	PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)pMem;
846
847	switch (pMemFreeBSD->Core.enmType)
848	{
849	case RTR0MEMOBJTYPE_LOCK:
850	{
851	if ( pMemFreeBSD->Core.u.Lock.R0Process != NIL_RTR0PROCESS
852	&& pMemFreeBSD->Core.u.Lock.R0Process != (RTR0PROCESS)curproc)
853	{
854	/* later */
855	return NIL_RTHCPHYS;
856	}
857
858	vm_offset_t pb = (vm_offset_t)pMemFreeBSD->Core.pv + ptoa(iPage);
859
860	struct proc pProc = (struct proc )pMemFreeBSD->Core.u.Lock.R0Process;
861	struct vm_map *pProcMap = &pProc->p_vmspace->vm_map;
862	pmap_t pPhysicalMap = vm_map_pmap(pProcMap);
863
864	return pmap_extract(pPhysicalMap, pb);
865	}
866
867	case RTR0MEMOBJTYPE_MAPPING:
868	{
869	vm_offset_t pb = (vm_offset_t)pMemFreeBSD->Core.pv + ptoa(iPage);
870
871	if (pMemFreeBSD->Core.u.Mapping.R0Process != NIL_RTR0PROCESS)
872	{
873	struct proc pProc = (struct proc )pMemFreeBSD->Core.u.Mapping.R0Process;
874	struct vm_map *pProcMap = &pProc->p_vmspace->vm_map;
875	pmap_t pPhysicalMap = vm_map_pmap(pProcMap);
876
877	return pmap_extract(pPhysicalMap, pb);
878	}
879	return vtophys(pb);
880	}
881
882	case RTR0MEMOBJTYPE_PAGE:
883	case RTR0MEMOBJTYPE_LOW:
884	case RTR0MEMOBJTYPE_PHYS_NC:
885	{
886	RTHCPHYS addr;
887
888	VM_OBJECT_WLOCK(pMemFreeBSD->pObject);
889	addr = VM_PAGE_TO_PHYS(vm_page_lookup(pMemFreeBSD->pObject, iPage));
890	VM_OBJECT_WUNLOCK(pMemFreeBSD->pObject);
891	return addr;
892	}
893
894	case RTR0MEMOBJTYPE_PHYS:
895	return pMemFreeBSD->Core.u.Cont.Phys + ptoa(iPage);
896
897	case RTR0MEMOBJTYPE_CONT:
898	return pMemFreeBSD->Core.u.Phys.PhysBase + ptoa(iPage);
899
900	case RTR0MEMOBJTYPE_RES_VIRT:
901	default:
902	return NIL_RTHCPHYS;
903	}
904	}
905

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

source: vbox/trunk/src/VBox/Runtime/r0drv/freebsd/memobj-r0drv-freebsd.c@ 91483

Download in other formats: