VirtualBox

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

最後變更 在這個檔案從20525是 20525,由 vboxsync 提交於 15 年 前

iprt/memobj.h: Added RTR0MemObjProtect, only implemented for darwin.
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Id
檔案大小: 17.9 KB
行 
1/* $Id: memobj-r0drv-os2.cpp 20525 2009-06-13 20:13:33Z vboxsync $ */
2/** @file
3 * IPRT - Ring-0 Memory Objects, OS/2.
4 */
5
6/*
7 * Copyright (c) 2007 knut st. osmundsen <[email protected]>
8 *
9 * Permission is hereby granted, free of charge, to any person
10 * obtaining a copy of this software and associated documentation
11 * files (the "Software"), to deal in the Software without
12 * restriction, including without limitation the rights to use,
13 * copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the
15 * Software is furnished to do so, subject to the following
16 * conditions:
17 *
18 * The above copyright notice and this permission notice shall be
19 * included in all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
23 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
25 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
26 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28 * OTHER DEALINGS IN THE SOFTWARE.
29 */
30
31
32/*******************************************************************************
33* Header Files *
34*******************************************************************************/
35#include "the-os2-kernel.h"
36
37#include <iprt/memobj.h>
38#include <iprt/mem.h>
39#include <iprt/err.h>
40#include <iprt/assert.h>
41#include <iprt/log.h>
42#include <iprt/param.h>
43#include <iprt/process.h>
44#include "internal/memobj.h"
45
46
47/*******************************************************************************
48* Structures and Typedefs *
49*******************************************************************************/
50/**
51 * The OS/2 version of the memory object structure.
52 */
53typedef struct RTR0MEMOBJDARWIN
54{
55 /** The core structure. */
56 RTR0MEMOBJINTERNAL Core;
57 /** Lock for the ring-3 / ring-0 pinned objectes.
58 * This member might not be allocated for some object types. */
59 KernVMLock_t Lock;
60 /** Array of physical pages.
61 * This array can be 0 in length for some object types. */
62 KernPageList_t aPages[1];
63} RTR0MEMOBJOS2, *PRTR0MEMOBJOS2;
64
65
66/*******************************************************************************
67* Internal Functions *
68*******************************************************************************/
69static void rtR0MemObjFixPageList(KernPageList_t *paPages, ULONG cPages, ULONG cPagesRet);
70
71
72int rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
73{
74 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)pMem;
75 int rc;
76
77 switch (pMemOs2->Core.enmType)
78 {
79 case RTR0MEMOBJTYPE_PHYS_NC:
80 AssertMsgFailed(("RTR0MEMOBJTYPE_PHYS_NC\n"));
81 return VERR_INTERNAL_ERROR;
82 break;
83
84 case RTR0MEMOBJTYPE_PHYS:
85 if (!pMemOs2->Core.pv)
86 break;
87
88 case RTR0MEMOBJTYPE_MAPPING:
89 if (pMemOs2->Core.u.Mapping.R0Process == NIL_RTR0PROCESS)
90 break;
91
92 /* fall thru */
93 case RTR0MEMOBJTYPE_PAGE:
94 case RTR0MEMOBJTYPE_LOW:
95 case RTR0MEMOBJTYPE_CONT:
96 rc = KernVMFree(pMemOs2->Core.pv);
97 AssertMsg(!rc, ("rc=%d type=%d pv=%p cb=%#zx\n", rc, pMemOs2->Core.enmType, pMemOs2->Core.pv, pMemOs2->Core.cb));
98 break;
99
100 case RTR0MEMOBJTYPE_LOCK:
101 rc = KernVMUnlock(&pMemOs2->Lock);
102 AssertMsg(!rc, ("rc=%d\n", rc));
103 break;
104
105 case RTR0MEMOBJTYPE_RES_VIRT:
106 default:
107 AssertMsgFailed(("enmType=%d\n", pMemOs2->Core.enmType));
108 return VERR_INTERNAL_ERROR;
109 }
110
111 return VINF_SUCCESS;
112}
113
114
115int rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
116{
117 NOREF(fExecutable);
118
119 /* create the object. */
120 const ULONG cPages = cb >> PAGE_SHIFT;
121 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_PAGE, NULL, cb);
122 if (!pMemOs2)
123 return VERR_NO_MEMORY;
124
125 /* do the allocation. */
126 int rc = KernVMAlloc(cb, VMDHA_FIXED, &pMemOs2->Core.pv, (PPVOID)-1, NULL);
127 if (!rc)
128 {
129 ULONG cPagesRet = cPages;
130 rc = KernLinToPageList(pMemOs2->Core.pv, cb, &pMemOs2->aPages[0], &cPagesRet);
131 if (!rc)
132 {
133 rtR0MemObjFixPageList(&pMemOs2->aPages[0], cPages, cPagesRet);
134 *ppMem = &pMemOs2->Core;
135 return VINF_SUCCESS;
136 }
137 KernVMFree(pMemOs2->Core.pv);
138 }
139 rtR0MemObjDelete(&pMemOs2->Core);
140 return RTErrConvertFromOS2(rc);
141}
142
143
144int rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
145{
146 NOREF(fExecutable);
147
148 /* create the object. */
149 const ULONG cPages = cb >> PAGE_SHIFT;
150 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOW, NULL, cb);
151 if (!pMemOs2)
152 return VERR_NO_MEMORY;
153
154 /* do the allocation. */
155 int rc = KernVMAlloc(cb, VMDHA_FIXED, &pMemOs2->Core.pv, (PPVOID)-1, NULL);
156 if (!rc)
157 {
158 ULONG cPagesRet = cPages;
159 rc = KernLinToPageList(pMemOs2->Core.pv, cb, &pMemOs2->aPages[0], &cPagesRet);
160 if (!rc)
161 {
162 rtR0MemObjFixPageList(&pMemOs2->aPages[0], cPages, cPagesRet);
163 *ppMem = &pMemOs2->Core;
164 return VINF_SUCCESS;
165 }
166 KernVMFree(pMemOs2->Core.pv);
167 }
168 rtR0MemObjDelete(&pMemOs2->Core);
169 return RTErrConvertFromOS2(rc);
170}
171
172
173int rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
174{
175 NOREF(fExecutable);
176
177 /* create the object. */
178 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_CONT, NULL, cb);
179 if (!pMemOs2)
180 return VERR_NO_MEMORY;
181
182 /* do the allocation. */
183 ULONG ulPhys = ~0UL;
184 int rc = KernVMAlloc(cb, VMDHA_FIXED | VMDHA_CONTIG, &pMemOs2->Core.pv, (PPVOID)&ulPhys, NULL);
185 if (!rc)
186 {
187 Assert(ulPhys != ~0UL);
188 pMemOs2->Core.u.Cont.Phys = ulPhys;
189 *ppMem = &pMemOs2->Core;
190 return VINF_SUCCESS;
191 }
192 rtR0MemObjDelete(&pMemOs2->Core);
193 return RTErrConvertFromOS2(rc);
194}
195
196
197int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
198{
199 AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%RHp\n", PhysHighest), VERR_NOT_IMPLEMENTED);
200
201 /* create the object. */
202 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_PHYS, NULL, cb);
203 if (!pMemOs2)
204 return VERR_NO_MEMORY;
205
206 /* do the allocation. */
207 ULONG ulPhys = ~0UL;
208 int rc = KernVMAlloc(cb, VMDHA_FIXED | VMDHA_CONTIG | (PhysHighest < _4G ? VMDHA_16M : 0), &pMemOs2->Core.pv, (PPVOID)&ulPhys, NULL);
209 if (!rc)
210 {
211 Assert(ulPhys != ~0UL);
212 pMemOs2->Core.u.Phys.fAllocated = true;
213 pMemOs2->Core.u.Phys.PhysBase = ulPhys;
214 *ppMem = &pMemOs2->Core;
215 return VINF_SUCCESS;
216 }
217 rtR0MemObjDelete(&pMemOs2->Core);
218 return RTErrConvertFromOS2(rc);
219}
220
221
222int rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
223{
224 /** @todo rtR0MemObjNativeAllocPhys / darwin. */
225 return rtR0MemObjNativeAllocPhys(ppMem, cb, PhysHighest);
226}
227
228
229int rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb)
230{
231 /* create the object. */
232 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_PHYS, NULL, cb);
233 if (!pMemOs2)
234 return VERR_NO_MEMORY;
235
236 /* there is no allocation here, right? it needs to be mapped somewhere first. */
237 pMemOs2->Core.u.Phys.fAllocated = false;
238 pMemOs2->Core.u.Phys.PhysBase = Phys;
239 *ppMem = &pMemOs2->Core;
240 return VINF_SUCCESS;
241}
242
243
244int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
245{
246 AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
247
248 /* create the object. */
249 const ULONG cPages = cb >> PAGE_SHIFT;
250 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
251 if (!pMemOs2)
252 return VERR_NO_MEMORY;
253
254 /* lock it. */
255 ULONG cPagesRet = cPages;
256 int rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE, (void *)R3Ptr, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
257 if (!rc)
258 {
259 rtR0MemObjFixPageList(&pMemOs2->aPages[0], cPages, cPagesRet);
260 Assert(cb == pMemOs2->Core.cb);
261 Assert(R3Ptr == (RTR3PTR)pMemOs2->Core.pv);
262 pMemOs2->Core.u.Lock.R0Process = R0Process;
263 *ppMem = &pMemOs2->Core;
264 return VINF_SUCCESS;
265 }
266 rtR0MemObjDelete(&pMemOs2->Core);
267 return RTErrConvertFromOS2(rc);
268}
269
270
271int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
272{
273 /* create the object. */
274 const ULONG cPages = cb >> PAGE_SHIFT;
275 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, aPages[cPages]), RTR0MEMOBJTYPE_LOCK, pv, cb);
276 if (!pMemOs2)
277 return VERR_NO_MEMORY;
278
279 /* lock it. */
280 ULONG cPagesRet = cPages;
281 int rc = KernVMLock(VMDHL_LONG | VMDHL_WRITE, pv, cb, &pMemOs2->Lock, &pMemOs2->aPages[0], &cPagesRet);
282 if (!rc)
283 {
284 rtR0MemObjFixPageList(&pMemOs2->aPages[0], cPages, cPagesRet);
285 pMemOs2->Core.u.Lock.R0Process = NIL_RTR0PROCESS;
286 *ppMem = &pMemOs2->Core;
287 return VINF_SUCCESS;
288 }
289 rtR0MemObjDelete(&pMemOs2->Core);
290 return RTErrConvertFromOS2(rc);
291}
292
293
294int rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment)
295{
296 return VERR_NOT_IMPLEMENTED;
297}
298
299
300int rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, RTR0PROCESS R0Process)
301{
302 return VERR_NOT_IMPLEMENTED;
303}
304
305
306int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment,
307 unsigned fProt, size_t offSub, size_t cbSub)
308{
309 AssertMsgReturn(!offSub && !cbSub, ("%#x %#x\n", offSub, cbSub), VERR_NOT_SUPPORTED);
310 AssertMsgReturn(pvFixed == (void *)-1, ("%p\n", pvFixed), VERR_NOT_SUPPORTED);
311
312/** @todo finish the implementation. */
313
314 int rc;
315 void *pvR0 = NULL;
316 PRTR0MEMOBJOS2 pMemToMapOs2 = (PRTR0MEMOBJOS2)pMemToMap;
317 switch (pMemToMapOs2->Core.enmType)
318 {
319 /*
320 * These has kernel mappings.
321 */
322 case RTR0MEMOBJTYPE_PAGE:
323 case RTR0MEMOBJTYPE_LOW:
324 case RTR0MEMOBJTYPE_CONT:
325 pvR0 = pMemToMapOs2->Core.pv;
326 break;
327
328 case RTR0MEMOBJTYPE_PHYS:
329 pvR0 = pMemToMapOs2->Core.pv;
330 if (!pvR0)
331 {
332 /* no ring-0 mapping, so allocate a mapping in the process. */
333 AssertMsgReturn(uAlignment == PAGE_SIZE, ("%#zx\n", uAlignment), VERR_NOT_SUPPORTED);
334 AssertMsgReturn(fProt & RTMEM_PROT_WRITE, ("%#x\n", fProt), VERR_NOT_SUPPORTED);
335 Assert(!pMemToMapOs2->Core.u.Phys.fAllocated);
336 ULONG ulPhys = pMemToMapOs2->Core.u.Phys.PhysBase;
337 rc = KernVMAlloc(pMemToMapOs2->Core.cb, VMDHA_PHYS, &pvR0, (PPVOID)&ulPhys, NULL);
338 if (rc)
339 return RTErrConvertFromOS2(rc);
340 pMemToMapOs2->Core.pv = pvR0;
341 }
342 break;
343
344 case RTR0MEMOBJTYPE_PHYS_NC:
345 AssertMsgFailed(("RTR0MEMOBJTYPE_PHYS_NC\n"));
346 return VERR_NOT_IMPLEMENTED;
347 break;
348
349 case RTR0MEMOBJTYPE_LOCK:
350 if (pMemToMapOs2->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
351 return VERR_NOT_SUPPORTED; /** @todo implement this... */
352 pvR0 = pMemToMapOs2->Core.pv;
353 break;
354
355 case RTR0MEMOBJTYPE_RES_VIRT:
356 case RTR0MEMOBJTYPE_MAPPING:
357 default:
358 AssertMsgFailed(("enmType=%d\n", pMemToMapOs2->Core.enmType));
359 return VERR_INTERNAL_ERROR;
360 }
361
362 /*
363 * Create a dummy mapping object for it.
364 *
365 * All mappings are read/write/execute in OS/2 and there isn't
366 * any cache options, so sharing is ok. And the main memory object
367 * isn't actually freed until all the mappings have been freed up
368 * (reference counting).
369 */
370 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING, pvR0, pMemToMapOs2->Core.cb);
371 if (pMemOs2)
372 {
373 pMemOs2->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
374 *ppMem = &pMemOs2->Core;
375 return VINF_SUCCESS;
376 }
377 return VERR_NO_MEMORY;
378}
379
380
381int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process)
382{
383 AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
384 AssertMsgReturn(R3PtrFixed == (RTR3PTR)-1, ("%p\n", R3PtrFixed), VERR_NOT_SUPPORTED);
385
386 int rc;
387 void *pvR0;
388 void *pvR3 = NULL;
389 PRTR0MEMOBJOS2 pMemToMapOs2 = (PRTR0MEMOBJOS2)pMemToMap;
390 switch (pMemToMapOs2->Core.enmType)
391 {
392 /*
393 * These has kernel mappings.
394 */
395 case RTR0MEMOBJTYPE_PAGE:
396 case RTR0MEMOBJTYPE_LOW:
397 case RTR0MEMOBJTYPE_CONT:
398 pvR0 = pMemToMapOs2->Core.pv;
399 break;
400
401 case RTR0MEMOBJTYPE_PHYS:
402 pvR0 = pMemToMapOs2->Core.pv;
403#if 0/* this is wrong. */
404 if (!pvR0)
405 {
406 /* no ring-0 mapping, so allocate a mapping in the process. */
407 AssertMsgReturn(uAlignment == PAGE_SIZE, ("%#zx\n", uAlignment), VERR_NOT_SUPPORTED);
408 AssertMsgReturn(fProt & RTMEM_PROT_WRITE, ("%#x\n", fProt), VERR_NOT_SUPPORTED);
409 Assert(!pMemToMapOs2->Core.u.Phys.fAllocated);
410 ULONG ulPhys = pMemToMapOs2->Core.u.Phys.PhysBase;
411 rc = KernVMAlloc(pMemToMapOs2->Core.cb, VMDHA_PHYS | VMDHA_PROCESS, &pvR3, (PPVOID)&ulPhys, NULL);
412 if (rc)
413 return RTErrConvertFromOS2(rc);
414 }
415 break;
416#endif
417 return VERR_NOT_SUPPORTED;
418
419 case RTR0MEMOBJTYPE_PHYS_NC:
420 AssertMsgFailed(("RTR0MEMOBJTYPE_PHYS_NC\n"));
421 return VERR_NOT_IMPLEMENTED;
422 break;
423
424 case RTR0MEMOBJTYPE_LOCK:
425 if (pMemToMapOs2->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
426 return VERR_NOT_SUPPORTED; /** @todo implement this... */
427 pvR0 = pMemToMapOs2->Core.pv;
428 break;
429
430 case RTR0MEMOBJTYPE_RES_VIRT:
431 case RTR0MEMOBJTYPE_MAPPING:
432 default:
433 AssertMsgFailed(("enmType=%d\n", pMemToMapOs2->Core.enmType));
434 return VERR_INTERNAL_ERROR;
435 }
436
437 /*
438 * Map the ring-0 memory into the current process.
439 */
440 if (!pvR3)
441 {
442 Assert(pvR0);
443 ULONG flFlags = 0;
444 if (uAlignment == PAGE_SIZE)
445 flFlags |= VMDHGP_4MB;
446 if (fProt & RTMEM_PROT_WRITE)
447 flFlags |= VMDHGP_WRITE;
448 rc = RTR0Os2DHVMGlobalToProcess(flFlags, pvR0, pMemToMapOs2->Core.cb, &pvR3);
449 if (rc)
450 return RTErrConvertFromOS2(rc);
451 }
452 Assert(pvR3);
453
454 /*
455 * Create a mapping object for it.
456 */
457 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING, pvR3, pMemToMapOs2->Core.cb);
458 if (pMemOs2)
459 {
460 Assert(pMemOs2->Core.pv == pvR3);
461 pMemOs2->Core.u.Mapping.R0Process = R0Process;
462 *ppMem = &pMemOs2->Core;
463 return VINF_SUCCESS;
464 }
465 KernVMFree(pvR3);
466 return VERR_NO_MEMORY;
467}
468
469
470int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
471{
472 NOREF(pMem);
473 NOREF(offSub);
474 NOREF(cbSub);
475 NOREF(fProt);
476 return VERR_NOT_SUPPORTED;
477}
478
479
480RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
481{
482 PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)pMem;
483
484 switch (pMemOs2->Core.enmType)
485 {
486 case RTR0MEMOBJTYPE_PAGE:
487 case RTR0MEMOBJTYPE_LOW:
488 case RTR0MEMOBJTYPE_LOCK:
489 case RTR0MEMOBJTYPE_PHYS_NC:
490 return pMemOs2->aPages[iPage].Addr;
491
492 case RTR0MEMOBJTYPE_CONT:
493 return pMemOs2->Core.u.Cont.Phys + (iPage << PAGE_SHIFT);
494
495 case RTR0MEMOBJTYPE_PHYS:
496 return pMemOs2->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);
497
498 case RTR0MEMOBJTYPE_RES_VIRT:
499 case RTR0MEMOBJTYPE_MAPPING:
500 default:
501 return NIL_RTHCPHYS;
502 }
503}
504
505
506/**
507 * Expands the page list so we can index pages directly.
508 *
509 * @param paPages The page list array to fix.
510 * @param cPages The number of pages that's supposed to go into the list.
511 * @param cPagesRet The actual number of pages in the list.
512 */
513static void rtR0MemObjFixPageList(KernPageList_t *paPages, ULONG cPages, ULONG cPagesRet)
514{
515 Assert(cPages >= cPagesRet);
516 if (cPages != cPagesRet)
517 {
518 ULONG iIn = cPagesRet;
519 ULONG iOut = cPages;
520 do
521 {
522 iIn--;
523 iOut--;
524 Assert(iIn <= iOut);
525
526 KernPageList_t Page = paPages[iIn];
527 Assert(!(Page.Addr & PAGE_OFFSET_MASK));
528 Assert(Page.Size == RT_ALIGN_Z(Page.Size, PAGE_SIZE));
529
530 if (Page.Size > PAGE_SIZE)
531 {
532 do
533 {
534 Page.Size -= PAGE_SIZE;
535 paPages[iOut].Addr = Page.Addr + Page.Size;
536 paPages[iOut].Size = PAGE_SIZE;
537 iOut--;
538 } while (Page.Size > PAGE_SIZE);
539 }
540
541 paPages[iOut].Addr = Page.Addr;
542 paPages[iOut].Size = PAGE_SIZE;
543 } while ( iIn != iOut
544 && iIn > 0);
545 }
546}
547
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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