memobj-r0drv-freebsd.c@ 77120

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

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

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

Download in other formats: