VirtualBox

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

Last change on this file since 44579 was 44528, checked in by vboxsync, 12 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette