VirtualBox

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

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use