memobj-r0drv-os2.cpp@ 13476

Last change on this file since 13476 was 8245, checked in by vboxsync, 17 years ago
rebranding: IPRT files again.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 17.6 KB

Line
1	/* $Id: memobj-r0drv-os2.cpp 8245 2008-04-21 17:24:28Z vboxsync $ */
2	/** @file
3	* IPRT - Ring-0 Memory Objects, OS/2.
4	*/
5
6	/*
7	* Copyright (c) 2007 knut st. osmundsen <bird-src-spam@anduin.net>
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	*/
53	typedef 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	*******************************************************************************/
69	static void rtR0MemObjFixPageList(KernPageList_t *paPages, ULONG cPages, ULONG cPagesRet);
70
71
72	int 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
115	int 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
144	int 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
173	int 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
197	int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
198	{
199	AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%VHp\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
222	int rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
223	{
224	/** @todo rtR0MemObjNativeAllocPhys / darwin. */
225	return rtR0MemObjNativeAllocPhys(ppMem, cb, PhysHighest);
226	}
227
228
229	int 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
244	int 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
271	int 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
294	int rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment)
295	{
296	return VERR_NOT_IMPLEMENTED;
297	}
298
299
300	int rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, RTR0PROCESS R0Process)
301	{
302	return VERR_NOT_IMPLEMENTED;
303	}
304
305
306	int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
307	{
308	AssertMsgReturn(pvFixed == (void *)-1, ("%p\n", pvFixed), VERR_NOT_SUPPORTED);
309
310	/** @todo finish the implementation. */
311
312	int rc;
313	void *pvR0 = NULL;
314	PRTR0MEMOBJOS2 pMemToMapOs2 = (PRTR0MEMOBJOS2)pMemToMap;
315	switch (pMemToMapOs2->Core.enmType)
316	{
317	/*
318	* These has kernel mappings.
319	*/
320	case RTR0MEMOBJTYPE_PAGE:
321	case RTR0MEMOBJTYPE_LOW:
322	case RTR0MEMOBJTYPE_CONT:
323	pvR0 = pMemToMapOs2->Core.pv;
324	break;
325
326	case RTR0MEMOBJTYPE_PHYS:
327	pvR0 = pMemToMapOs2->Core.pv;
328	if (!pvR0)
329	{
330	/* no ring-0 mapping, so allocate a mapping in the process. */
331	AssertMsgReturn(uAlignment == PAGE_SIZE, ("%#zx\n", uAlignment), VERR_NOT_SUPPORTED);
332	AssertMsgReturn(fProt & RTMEM_PROT_WRITE, ("%#x\n", fProt), VERR_NOT_SUPPORTED);
333	Assert(!pMemToMapOs2->Core.u.Phys.fAllocated);
334	ULONG ulPhys = pMemToMapOs2->Core.u.Phys.PhysBase;
335	rc = KernVMAlloc(pMemToMapOs2->Core.cb, VMDHA_PHYS, &pvR0, (PPVOID)&ulPhys, NULL);
336	if (rc)
337	return RTErrConvertFromOS2(rc);
338	pMemToMapOs2->Core.pv = pvR0;
339	}
340	break;
341
342	case RTR0MEMOBJTYPE_PHYS_NC:
343	AssertMsgFailed(("RTR0MEMOBJTYPE_PHYS_NC\n"));
344	return VERR_NOT_IMPLEMENTED;
345	break;
346
347	case RTR0MEMOBJTYPE_LOCK:
348	if (pMemToMapOs2->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
349	return VERR_NOT_SUPPORTED; /** @todo implement this... */
350	pvR0 = pMemToMapOs2->Core.pv;
351	break;
352
353	case RTR0MEMOBJTYPE_RES_VIRT:
354	case RTR0MEMOBJTYPE_MAPPING:
355	default:
356	AssertMsgFailed(("enmType=%d\n", pMemToMapOs2->Core.enmType));
357	return VERR_INTERNAL_ERROR;
358	}
359
360	/*
361	* Create a dummy mapping object for it.
362	*
363	* All mappings are read/write/execute in OS/2 and there isn't
364	* any cache options, so sharing is ok. And the main memory object
365	* isn't actually freed until all the mappings have been freed up
366	* (reference counting).
367	*/
368	PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING, pvR0, pMemToMapOs2->Core.cb);
369	if (pMemOs2)
370	{
371	pMemOs2->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
372	*ppMem = &pMemOs2->Core;
373	return VINF_SUCCESS;
374	}
375	return VERR_NO_MEMORY;
376	}
377
378
379	int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process)
380	{
381	AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
382	AssertMsgReturn(R3PtrFixed == (RTR3PTR)-1, ("%p\n", R3PtrFixed), VERR_NOT_SUPPORTED);
383
384	int rc;
385	void *pvR0;
386	void *pvR3 = NULL;
387	PRTR0MEMOBJOS2 pMemToMapOs2 = (PRTR0MEMOBJOS2)pMemToMap;
388	switch (pMemToMapOs2->Core.enmType)
389	{
390	/*
391	* These has kernel mappings.
392	*/
393	case RTR0MEMOBJTYPE_PAGE:
394	case RTR0MEMOBJTYPE_LOW:
395	case RTR0MEMOBJTYPE_CONT:
396	pvR0 = pMemToMapOs2->Core.pv;
397	break;
398
399	case RTR0MEMOBJTYPE_PHYS:
400	pvR0 = pMemToMapOs2->Core.pv;
401	#if 0/* this is wrong. */
402	if (!pvR0)
403	{
404	/* no ring-0 mapping, so allocate a mapping in the process. */
405	AssertMsgReturn(uAlignment == PAGE_SIZE, ("%#zx\n", uAlignment), VERR_NOT_SUPPORTED);
406	AssertMsgReturn(fProt & RTMEM_PROT_WRITE, ("%#x\n", fProt), VERR_NOT_SUPPORTED);
407	Assert(!pMemToMapOs2->Core.u.Phys.fAllocated);
408	ULONG ulPhys = pMemToMapOs2->Core.u.Phys.PhysBase;
409	rc = KernVMAlloc(pMemToMapOs2->Core.cb, VMDHA_PHYS \| VMDHA_PROCESS, &pvR3, (PPVOID)&ulPhys, NULL);
410	if (rc)
411	return RTErrConvertFromOS2(rc);
412	}
413	break;
414	#endif
415	return VERR_NOT_SUPPORTED;
416
417	case RTR0MEMOBJTYPE_PHYS_NC:
418	AssertMsgFailed(("RTR0MEMOBJTYPE_PHYS_NC\n"));
419	return VERR_NOT_IMPLEMENTED;
420	break;
421
422	case RTR0MEMOBJTYPE_LOCK:
423	if (pMemToMapOs2->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
424	return VERR_NOT_SUPPORTED; /** @todo implement this... */
425	pvR0 = pMemToMapOs2->Core.pv;
426	break;
427
428	case RTR0MEMOBJTYPE_RES_VIRT:
429	case RTR0MEMOBJTYPE_MAPPING:
430	default:
431	AssertMsgFailed(("enmType=%d\n", pMemToMapOs2->Core.enmType));
432	return VERR_INTERNAL_ERROR;
433	}
434
435	/*
436	* Map the ring-0 memory into the current process.
437	*/
438	if (!pvR3)
439	{
440	Assert(pvR0);
441	ULONG flFlags = 0;
442	if (uAlignment == PAGE_SIZE)
443	flFlags \|= VMDHGP_4MB;
444	if (fProt & RTMEM_PROT_WRITE)
445	flFlags \|= VMDHGP_WRITE;
446	rc = RTR0Os2DHVMGlobalToProcess(flFlags, pvR0, pMemToMapOs2->Core.cb, &pvR3);
447	if (rc)
448	return RTErrConvertFromOS2(rc);
449	}
450	Assert(pvR3);
451
452	/*
453	* Create a mapping object for it.
454	*/
455	PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)rtR0MemObjNew(RT_OFFSETOF(RTR0MEMOBJOS2, Lock), RTR0MEMOBJTYPE_MAPPING, pvR3, pMemToMapOs2->Core.cb);
456	if (pMemOs2)
457	{
458	Assert(pMemOs2->Core.pv == pvR3);
459	pMemOs2->Core.u.Mapping.R0Process = R0Process;
460	*ppMem = &pMemOs2->Core;
461	return VINF_SUCCESS;
462	}
463	KernVMFree(pvR3);
464	return VERR_NO_MEMORY;
465	}
466
467
468	RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
469	{
470	PRTR0MEMOBJOS2 pMemOs2 = (PRTR0MEMOBJOS2)pMem;
471
472	switch (pMemOs2->Core.enmType)
473	{
474	case RTR0MEMOBJTYPE_PAGE:
475	case RTR0MEMOBJTYPE_LOW:
476	case RTR0MEMOBJTYPE_LOCK:
477	case RTR0MEMOBJTYPE_PHYS_NC:
478	return pMemOs2->aPages[iPage].Addr;
479
480	case RTR0MEMOBJTYPE_CONT:
481	return pMemOs2->Core.u.Cont.Phys + (iPage << PAGE_SHIFT);
482
483	case RTR0MEMOBJTYPE_PHYS:
484	return pMemOs2->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);
485
486	case RTR0MEMOBJTYPE_RES_VIRT:
487	case RTR0MEMOBJTYPE_MAPPING:
488	default:
489	return NIL_RTHCPHYS;
490	}
491	}
492
493
494	/**
495	* Expands the page list so we can index pages directly.
496	*
497	* @param paPages The page list array to fix.
498	* @param cPages The number of pages that's supposed to go into the list.
499	* @param cPagesRet The actual number of pages in the list.
500	*/
501	static void rtR0MemObjFixPageList(KernPageList_t *paPages, ULONG cPages, ULONG cPagesRet)
502	{
503	Assert(cPages >= cPagesRet);
504	if (cPages != cPagesRet)
505	{
506	ULONG iIn = cPagesRet;
507	ULONG iOut = cPages;
508	do
509	{
510	iIn--;
511	iOut--;
512	Assert(iIn <= iOut);
513
514	KernPageList_t Page = paPages[iIn];
515	Assert(!(Page.Addr & PAGE_OFFSET_MASK));
516	Assert(Page.Size == RT_ALIGN_Z(Page.Size, PAGE_SIZE));
517
518	if (Page.Size > PAGE_SIZE)
519	{
520	do
521	{
522	Page.Size -= PAGE_SIZE;
523	paPages[iOut].Addr = Page.Addr + Page.Size;
524	paPages[iOut].Size = PAGE_SIZE;
525	iOut--;
526	} while (Page.Size > PAGE_SIZE);
527	}
528
529	paPages[iOut].Addr = Page.Addr;
530	paPages[iOut].Size = PAGE_SIZE;
531	} while ( iIn != iOut
532	&& iIn > 0);
533	}
534	}
535

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

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

Download in other formats: