memobj-r0drv-haiku.c@ 92258

Last change on this file since 92258 was 91483, checked in by vboxsync, 3 years ago
IPRT/memobj: Passing pszTag around...
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.9 KB

Line
1	/* $Id: memobj-r0drv-haiku.c 91483 2021-09-30 00:19:19Z vboxsync $ */
2	/** @file
3	* IPRT - Ring-0 Memory Objects, Haiku.
4	*/
5
6	/*
7	* Copyright (C) 2012-2020 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	#include "the-haiku-kernel.h"
32
33	#include <iprt/memobj.h>
34	#include <iprt/mem.h>
35	#include <iprt/err.h>
36	#include <iprt/assert.h>
37	#include <iprt/log.h>
38	#include <iprt/param.h>
39	#include <iprt/process.h>
40	#include "internal/memobj.h"
41
42
43	/*********************************************************************************************************************************
44	* Structures and Typedefs *
45	*********************************************************************************************************************************/
46	/**
47	* The Haiku version of the memory object structure.
48	*/
49	typedef struct RTR0MEMOBJHAIKU
50	{
51	/** The core structure. */
52	RTR0MEMOBJINTERNAL Core;
53	/** Area identifier */
54	area_id AreaId;
55	} RTR0MEMOBJHAIKU, *PRTR0MEMOBJHAIKU;
56
57
58	//MALLOC_DEFINE(M_IPRTMOBJ, "iprtmobj", "IPRT - R0MemObj");
59	#if 0
60	/**
61	* Gets the virtual memory map the specified object is mapped into.
62	*
63	* @returns VM map handle on success, NULL if no map.
64	* @param pMem The memory object.
65	*/
66	static vm_map_t rtR0MemObjHaikuGetMap(PRTR0MEMOBJINTERNAL pMem)
67	{
68	switch (pMem->enmType)
69	{
70	case RTR0MEMOBJTYPE_PAGE:
71	case RTR0MEMOBJTYPE_LOW:
72	case RTR0MEMOBJTYPE_CONT:
73	return kernel_map;
74
75	case RTR0MEMOBJTYPE_PHYS:
76	case RTR0MEMOBJTYPE_PHYS_NC:
77	return NULL; /* pretend these have no mapping atm. */
78
79	case RTR0MEMOBJTYPE_LOCK:
80	return pMem->u.Lock.R0Process == NIL_RTR0PROCESS
81	? kernel_map
82	: &((struct proc *)pMem->u.Lock.R0Process)->p_vmspace->vm_map;
83
84	case RTR0MEMOBJTYPE_RES_VIRT:
85	return pMem->u.ResVirt.R0Process == NIL_RTR0PROCESS
86	? kernel_map
87	: &((struct proc *)pMem->u.ResVirt.R0Process)->p_vmspace->vm_map;
88
89	case RTR0MEMOBJTYPE_MAPPING:
90	return pMem->u.Mapping.R0Process == NIL_RTR0PROCESS
91	? kernel_map
92	: &((struct proc *)pMem->u.Mapping.R0Process)->p_vmspace->vm_map;
93
94	default:
95	return NULL;
96	}
97	}
98	#endif
99
100
101	int rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
102	{
103	PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)pMem;
104	int rc = B_OK;
105
106	switch (pMemHaiku->Core.enmType)
107	{
108	case RTR0MEMOBJTYPE_PAGE:
109	case RTR0MEMOBJTYPE_LOW:
110	case RTR0MEMOBJTYPE_CONT:
111	case RTR0MEMOBJTYPE_MAPPING:
112	case RTR0MEMOBJTYPE_PHYS:
113	case RTR0MEMOBJTYPE_PHYS_NC:
114	{
115	if (pMemHaiku->AreaId > -1)
116	rc = delete_area(pMemHaiku->AreaId);
117
118	AssertMsg(rc == B_OK, ("%#x", rc));
119	break;
120	}
121
122	case RTR0MEMOBJTYPE_LOCK:
123	{
124	team_id team = B_SYSTEM_TEAM;
125
126	if (pMemHaiku->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
127	team = ((team_id)pMemHaiku->Core.u.Lock.R0Process);
128
129	rc = unlock_memory_etc(team, pMemHaiku->Core.pv, pMemHaiku->Core.cb, B_READ_DEVICE);
130	AssertMsg(rc == B_OK, ("%#x", rc));
131	break;
132	}
133
134	case RTR0MEMOBJTYPE_RES_VIRT:
135	{
136	team_id team = B_SYSTEM_TEAM;
137	if (pMemHaiku->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
138	team = ((team_id)pMemHaiku->Core.u.Lock.R0Process);
139
140	rc = vm_unreserve_address_range(team, pMemHaiku->Core.pv, pMemHaiku->Core.cb);
141	AssertMsg(rc == B_OK, ("%#x", rc));
142	break;
143	}
144
145	default:
146	AssertMsgFailed(("enmType=%d\n", pMemHaiku->Core.enmType));
147	return VERR_INTERNAL_ERROR;
148	}
149
150	return VINF_SUCCESS;
151	}
152
153
154	static int rtR0MemObjNativeAllocArea(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, RTR0MEMOBJTYPE enmType,
155	RTHCPHYS PhysHighest, size_t uAlignment, const char *pszTag)
156	{
157	NOREF(fExecutable);
158
159	int rc;
160	void *pvMap = NULL;
161	const char *pszName = NULL;
162	uint32 addressSpec = B_ANY_KERNEL_ADDRESS;
163	uint32 fLock = ~0U;
164	LogFlowFunc(("ppMem=%p cb=%u, fExecutable=%s, enmType=%08x, PhysHighest=%RX64 uAlignment=%u\n", ppMem,(unsigned)cb,
165	fExecutable ? "true" : "false", enmType, PhysHighest,(unsigned)uAlignment));
166
167	switch (enmType)
168	{
169	case RTR0MEMOBJTYPE_PAGE:
170	pszName = "IPRT R0MemObj Alloc";
171	fLock = B_FULL_LOCK;
172	break;
173	case RTR0MEMOBJTYPE_LOW:
174	pszName = "IPRT R0MemObj AllocLow";
175	fLock = B_32_BIT_FULL_LOCK;
176	break;
177	case RTR0MEMOBJTYPE_CONT:
178	pszName = "IPRT R0MemObj AllocCont";
179	fLock = B_32_BIT_CONTIGUOUS;
180	break;
181	#if 0
182	case RTR0MEMOBJTYPE_MAPPING:
183	pszName = "IPRT R0MemObj Mapping";
184	fLock = B_FULL_LOCK;
185	break;
186	#endif
187	case RTR0MEMOBJTYPE_PHYS:
188	/** @todo alignment */
189	if (uAlignment != PAGE_SIZE)
190	return VERR_NOT_SUPPORTED;
191	/** @todo r=ramshankar: no 'break' here?? */
192	case RTR0MEMOBJTYPE_PHYS_NC:
193	pszName = "IPRT R0MemObj AllocPhys";
194	fLock = (PhysHighest < _4G ? B_LOMEM : B_32_BIT_CONTIGUOUS);
195	break;
196	#if 0
197	case RTR0MEMOBJTYPE_LOCK:
198	break;
199	#endif
200	default:
201	return VERR_INTERNAL_ERROR;
202	}
203
204	/* Create the object. */
205	PRTR0MEMOBJHAIKU pMemHaiku;
206	pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(RTR0MEMOBJHAIKU), enmType, NULL, cb, pszTag);
207	if (RT_UNLIKELY(!pMemHaiku))
208	return VERR_NO_MEMORY;
209
210	rc = pMemHaiku->AreaId = create_area(pszName, &pvMap, addressSpec, cb, fLock, B_READ_AREA \| B_WRITE_AREA);
211	if (pMemHaiku->AreaId >= 0)
212	{
213	physical_entry physMap[2];
214	pMemHaiku->Core.pv = pvMap; /* store start address */
215	switch (enmType)
216	{
217	case RTR0MEMOBJTYPE_CONT:
218	rc = get_memory_map(pvMap, cb, physMap, 2);
219	if (rc == B_OK)
220	pMemHaiku->Core.u.Cont.Phys = physMap[0].address;
221	break;
222
223	case RTR0MEMOBJTYPE_PHYS:
224	case RTR0MEMOBJTYPE_PHYS_NC:
225	rc = get_memory_map(pvMap, cb, physMap, 2);
226	if (rc == B_OK)
227	{
228	pMemHaiku->Core.u.Phys.PhysBase = physMap[0].address;
229	pMemHaiku->Core.u.Phys.fAllocated = true;
230	}
231	break;
232
233	default:
234	break;
235	}
236	if (rc >= B_OK)
237	{
238	*ppMem = &pMemHaiku->Core;
239	return VINF_SUCCESS;
240	}
241
242	delete_area(pMemHaiku->AreaId);
243	}
244
245	rtR0MemObjDelete(&pMemHaiku->Core);
246	return RTErrConvertFromHaikuKernReturn(rc);
247	}
248
249
250	int rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
251	{
252	return rtR0MemObjNativeAllocArea(ppMem, cb, fExecutable, RTR0MEMOBJTYPE_PAGE, 0 /* PhysHighest /, 0 / uAlignment */, pszTag);
253	}
254
255
256	DECLHIDDEN(int) rtR0MemObjNativeAllocLarge(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, size_t cbLargePage, uint32_t fFlags,
257	const char *pszTag)
258	{
259	return rtR0MemObjFallbackAllocLarge(ppMem, cb, cbLargePage, fFlags, pszTag);
260	}
261
262
263	int rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
264	{
265	return rtR0MemObjNativeAllocArea(ppMem, cb, fExecutable, RTR0MEMOBJTYPE_LOW, 0 /* PhysHighest /, 0 / uAlignment */, pszTag);
266	}
267
268
269	int rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable, const char *pszTag)
270	{
271	return rtR0MemObjNativeAllocArea(ppMem, cb, fExecutable, RTR0MEMOBJTYPE_CONT, 0 /* PhysHighest /, 0 / uAlignment */, pszTag);
272	}
273
274	int rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, size_t uAlignment, const char *pszTag)
275	{
276	return rtR0MemObjNativeAllocArea(ppMem, cb, false, RTR0MEMOBJTYPE_PHYS, PhysHighest, uAlignment, pszTag);
277	}
278
279
280	int rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest, const char *pszTag)
281	{
282	return rtR0MemObjNativeAllocPhys(ppMem, cb, PhysHighest, PAGE_SIZE, pszTag);
283	}
284
285
286	int rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb, uint32_t uCachePolicy, const char *pszTag)
287	{
288	AssertReturn(uCachePolicy == RTMEM_CACHE_POLICY_DONT_CARE, VERR_NOT_SUPPORTED);
289	LogFlowFunc(("ppMem=%p Phys=%08x cb=%u uCachePolicy=%x\n", ppMem, Phys,(unsigned)cb, uCachePolicy));
290
291	/* Create the object. */
292	PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(*pMemHaiku), RTR0MEMOBJTYPE_PHYS, NULL, cb, pszTag);
293	if (!pMemHaiku)
294	return VERR_NO_MEMORY;
295
296	/* There is no allocation here, it needs to be mapped somewhere first. */
297	pMemHaiku->AreaId = -1;
298	pMemHaiku->Core.u.Phys.fAllocated = false;
299	pMemHaiku->Core.u.Phys.PhysBase = Phys;
300	pMemHaiku->Core.u.Phys.uCachePolicy = uCachePolicy;
301	*ppMem = &pMemHaiku->Core;
302	return VINF_SUCCESS;
303	}
304
305
306	/**
307	* Worker locking the memory in either kernel or user maps.
308	*
309	* @returns IPRT status code.
310	* @param ppMem Where to store the allocated memory object.
311	* @param pvStart The starting address.
312	* @param cb The size of the block.
313	* @param fAccess The mapping protection to apply.
314	* @param R0Process The process to map the memory to (use NIL_RTR0PROCESS
315	* for the kernel)
316	* @param fFlags Memory flags (B_READ_DEVICE indicates the memory is
317	* intended to be written from a "device").
318	* @param pszTag Allocation tag used for statistics and such.
319	*/
320	static int rtR0MemObjNativeLockInMap(PPRTR0MEMOBJINTERNAL ppMem, void *pvStart, size_t cb, uint32_t fAccess,
321	RTR0PROCESS R0Process, int fFlags, const char *pszTag)
322	{
323	NOREF(fAccess);
324	team_id TeamId = B_SYSTEM_TEAM;
325
326	LogFlowFunc(("ppMem=%p pvStart=%p cb=%u fAccess=%x R0Process=%d fFlags=%x\n", ppMem, pvStart, cb, fAccess, R0Process,
327	fFlags));
328
329	/* Create the object. */
330	PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(*pMemHaiku), RTR0MEMOBJTYPE_LOCK, pvStart, cb, pszTag);
331	if (RT_UNLIKELY(!pMemHaiku))
332	return VERR_NO_MEMORY;
333
334	if (R0Process != NIL_RTR0PROCESS)
335	TeamId = (team_id)R0Process;
336	int rc = lock_memory_etc(TeamId, pvStart, cb, fFlags);
337	if (rc == B_OK)
338	{
339	pMemHaiku->AreaId = -1;
340	pMemHaiku->Core.u.Lock.R0Process = R0Process;
341	*ppMem = &pMemHaiku->Core;
342	return VINF_SUCCESS;
343	}
344	rtR0MemObjDelete(&pMemHaiku->Core);
345	return RTErrConvertFromHaikuKernReturn(rc);
346	}
347
348
349	int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, uint32_t fAccess, RTR0PROCESS R0Process,
350	const char *pszTag)
351	{
352	return rtR0MemObjNativeLockInMap(ppMem, (void *)R3Ptr, cb, fAccess, R0Process, B_READ_DEVICE, pszTag);
353	}
354
355
356	int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void pv, size_t cb, uint32_t fAccess, const char pszTag)
357	{
358	return rtR0MemObjNativeLockInMap(ppMem, pv, cb, fAccess, NIL_RTR0PROCESS, B_READ_DEVICE, pszTag);
359	}
360
361
362	#if 0
363	/** @todo Reserve address space */
364	/**
365	* Worker for the two virtual address space reservers.
366	*
367	* We're leaning on the examples provided by mmap and vm_mmap in vm_mmap.c here.
368	*/
369	static int rtR0MemObjNativeReserveInMap(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment,
370	RTR0PROCESS R0Process)
371	{
372	int rc;
373	team_id TeamId = B_SYSTEM_TEAM;
374
375	LogFlowFunc(("ppMem=%p pvFixed=%p cb=%u uAlignment=%u R0Process=%d\n", ppMem, pvFixed, (unsigned)cb, uAlignment, R0Process));
376
377	if (R0Process != NIL_RTR0PROCESS)
378	team = (team_id)R0Process;
379
380	/* Check that the specified alignment is supported. */
381	if (uAlignment > PAGE_SIZE)
382	return VERR_NOT_SUPPORTED;
383
384	/* Create the object. */
385	PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(*pMemHaiku), RTR0MEMOBJTYPE_RES_VIRT, NULL, cb);
386	if (!pMemHaiku)
387	return VERR_NO_MEMORY;
388
389	/* Ask the kernel to reserve the address range. */
390	//XXX: vm_reserve_address_range ?
391	return VERR_NOT_SUPPORTED;
392	}
393	#endif
394
395
396	int rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void pvFixed, size_t cb, size_t uAlignment, const char pszTag)
397	{
398	RT_NOREF(ppMem, pvFixed, cb, uAlignment, pszTag);
399	return VERR_NOT_SUPPORTED;
400	}
401
402
403	int rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment,
404	RTR0PROCESS R0Process, const char *pszTag)
405	{
406	RT_NOREF(ppMem, R3PtrFixed, cb, uAlignment, R0Process, pszTag);
407	return VERR_NOT_SUPPORTED;
408	}
409
410
411	int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment,
412	unsigned fProt, size_t offSub, size_t cbSub, const char *pszTag)
413	{
414	PRTR0MEMOBJHAIKU pMemToMapHaiku = (PRTR0MEMOBJHAIKU)pMemToMap;
415	PRTR0MEMOBJHAIKU pMemHaiku;
416	area_id area = -1;
417	void *pvMap = pvFixed;
418	uint32 uAddrSpec = B_EXACT_ADDRESS;
419	uint32 fProtect = 0;
420	int rc = VERR_MAP_FAILED;
421	AssertMsgReturn(!offSub && !cbSub, ("%#x %#x\n", offSub, cbSub), VERR_NOT_SUPPORTED);
422	AssertMsgReturn(pvFixed == (void *)-1, ("%p\n", pvFixed), VERR_NOT_SUPPORTED);
423	#if 0
424	/** @todo r=ramshankar: Wrong format specifiers, fix later! */
425	dprintf("%s(%p, %p, %p, %d, %x, %u, %u)\n", __FUNCTION__, ppMem, pMemToMap, pvFixed, uAlignment,
426	fProt, offSub, cbSub);
427	#endif
428	/* Check that the specified alignment is supported. */
429	if (uAlignment > PAGE_SIZE)
430	return VERR_NOT_SUPPORTED;
431
432	/* We can't map anything to the first page, sorry. */
433	if (pvFixed == 0)
434	return VERR_NOT_SUPPORTED;
435
436	if (fProt & RTMEM_PROT_READ)
437	fProtect \|= B_KERNEL_READ_AREA;
438	if (fProt & RTMEM_PROT_WRITE)
439	fProtect \|= B_KERNEL_WRITE_AREA;
440
441	/*
442	* Either the object we map has an area associated with, which we can clone,
443	* or it's a physical address range which we must map.
444	*/
445	if (pMemToMapHaiku->AreaId > -1)
446	{
447	if (pvFixed == (void *)-1)
448	uAddrSpec = B_ANY_KERNEL_ADDRESS;
449
450	rc = area = clone_area("IPRT R0MemObj MapKernel", &pvMap, uAddrSpec, fProtect, pMemToMapHaiku->AreaId);
451	LogFlow(("rtR0MemObjNativeMapKernel: clone_area uAddrSpec=%d fProtect=%x AreaId=%d rc=%d\n", uAddrSpec, fProtect,
452	pMemToMapHaiku->AreaId, rc));
453	}
454	else if (pMemToMapHaiku->Core.enmType == RTR0MEMOBJTYPE_PHYS)
455	{
456	/* map_physical_memory() won't let you choose where. */
457	if (pvFixed != (void *)-1)
458	return VERR_NOT_SUPPORTED;
459	uAddrSpec = B_ANY_KERNEL_ADDRESS;
460
461	rc = area = map_physical_memory("IPRT R0MemObj MapKernelPhys", (phys_addr_t)pMemToMapHaiku->Core.u.Phys.PhysBase,
462	pMemToMapHaiku->Core.cb, uAddrSpec, fProtect, &pvMap);
463	}
464	else
465	return VERR_NOT_SUPPORTED;
466
467	if (rc >= B_OK)
468	{
469	/* Create the object. */
470	pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(RTR0MEMOBJHAIKU), RTR0MEMOBJTYPE_MAPPING, pvMap,
471	pMemToMapHaiku->Core.cb, pszTag);
472	if (RT_UNLIKELY(!pMemHaiku))
473	return VERR_NO_MEMORY;
474
475	pMemHaiku->Core.u.Mapping.R0Process = NIL_RTR0PROCESS;
476	pMemHaiku->Core.pv = pvMap;
477	pMemHaiku->AreaId = area;
478	*ppMem = &pMemHaiku->Core;
479	return VINF_SUCCESS;
480	}
481	rc = VERR_MAP_FAILED;
482
483	/** @todo finish the implementation. */
484
485	rtR0MemObjDelete(&pMemHaiku->Core);
486	return rc;
487	}
488
489
490	int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment,
491	unsigned fProt, RTR0PROCESS R0Process, size_t offSub, size_t cbSub, const char *pszTag)
492	{
493	#if 0
494	/*
495	* Check for unsupported stuff.
496	*/
497	AssertMsgReturn(R0Process == RTR0ProcHandleSelf(), ("%p != %p\n", R0Process, RTR0ProcHandleSelf()), VERR_NOT_SUPPORTED);
498	AssertMsgReturn(R3PtrFixed == (RTR3PTR)-1, ("%p\n", R3PtrFixed), VERR_NOT_SUPPORTED);
499	if (uAlignment > PAGE_SIZE)
500	return VERR_NOT_SUPPORTED;
501	AssertMsgReturn(!offSub && !cbSub, ("%#zx %#zx\n", offSub, cbSub), VERR_NOT_SUPPORTED); /** @todo implement sub maps */
502
503	int rc;
504	PRTR0MEMOBJHAIKU pMemToMapHaiku = (PRTR0MEMOBJHAIKU)pMemToMap;
505	struct proc pProc = (struct proc )R0Process;
506	struct vm_map *pProcMap = &pProc->p_vmspace->vm_map;
507
508	/* calc protection */
509	vm_prot_t ProtectionFlags = 0;
510	if ((fProt & RTMEM_PROT_NONE) == RTMEM_PROT_NONE)
511	ProtectionFlags = VM_PROT_NONE;
512	if ((fProt & RTMEM_PROT_READ) == RTMEM_PROT_READ)
513	ProtectionFlags \|= VM_PROT_READ;
514	if ((fProt & RTMEM_PROT_WRITE) == RTMEM_PROT_WRITE)
515	ProtectionFlags \|= VM_PROT_WRITE;
516	if ((fProt & RTMEM_PROT_EXEC) == RTMEM_PROT_EXEC)
517	ProtectionFlags \|= VM_PROT_EXECUTE;
518
519	/* calc mapping address */
520	PROC_LOCK(pProc);
521	vm_offset_t AddrR3 = round_page((vm_offset_t)pProc->p_vmspace->vm_daddr + lim_max(pProc, RLIMIT_DATA));
522	PROC_UNLOCK(pProc);
523
524	/* Insert the object in the map. */
525	rc = vm_map_find(pProcMap, /* Map to insert the object in */
526	NULL, /* Object to map */
527	0, /* Start offset in the object */
528	&AddrR3, /* Start address IN/OUT */
529	pMemToMap->cb, /* Size of the mapping */
530	TRUE, /* Whether a suitable address should be searched for first */
531	ProtectionFlags, /* protection flags */
532	VM_PROT_ALL, /* Maximum protection flags */
533	0); /* Copy on write */
534
535	/* Map the memory page by page into the destination map. */
536	if (rc == KERN_SUCCESS)
537	{
538	size_t cPages = pMemToMap->cb >> PAGE_SHIFT;;
539	pmap_t pPhysicalMap = pProcMap->pmap;
540	vm_offset_t AddrR3Dst = AddrR3;
541
542	if ( pMemToMap->enmType == RTR0MEMOBJTYPE_PHYS
543	\|\| pMemToMap->enmType == RTR0MEMOBJTYPE_PHYS_NC
544	\|\| pMemToMap->enmType == RTR0MEMOBJTYPE_PAGE)
545	{
546	/* Mapping physical allocations */
547	Assert(cPages == pMemToMapHaiku->u.Phys.cPages);
548
549	/* Insert the memory page by page into the mapping. */
550	for (uint32_t iPage = 0; iPage < cPages; iPage++)
551	{
552	vm_page_t pPage = pMemToMapHaiku->u.Phys.apPages[iPage];
553
554	MY_PMAP_ENTER(pPhysicalMap, AddrR3Dst, pPage, ProtectionFlags, TRUE);
555	AddrR3Dst += PAGE_SIZE;
556	}
557	}
558	else
559	{
560	/* Mapping cont or low memory types */
561	vm_offset_t AddrToMap = (vm_offset_t)pMemToMap->pv;
562
563	for (uint32_t iPage = 0; iPage < cPages; iPage++)
564	{
565	vm_page_t pPage = PHYS_TO_VM_PAGE(vtophys(AddrToMap));
566
567	MY_PMAP_ENTER(pPhysicalMap, AddrR3Dst, pPage, ProtectionFlags, TRUE);
568	AddrR3Dst += PAGE_SIZE;
569	AddrToMap += PAGE_SIZE;
570	}
571	}
572	}
573
574	if (RT_SUCCESS(rc))
575	{
576	/*
577	* Create a mapping object for it.
578	*/
579	PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)rtR0MemObjNew(sizeof(RTR0MEMOBJHAIKU), RTR0MEMOBJTYPE_MAPPING,
580	(void *)AddrR3, pMemToMap->cb, pszTag);
581	if (pMemHaiku)
582	{
583	Assert((vm_offset_t)pMemHaiku->Core.pv == AddrR3);
584	pMemHaiku->Core.u.Mapping.R0Process = R0Process;
585	*ppMem = &pMemHaiku->Core;
586	return VINF_SUCCESS;
587	}
588
589	rc = vm_map_remove(pProcMap, ((vm_offset_t)AddrR3), ((vm_offset_t)AddrR3) + pMemToMap->cb);
590	AssertMsg(rc == KERN_SUCCESS, ("Deleting mapping failed\n"));
591	}
592	#else
593	RT_NOREF(ppMem, pMemToMap, R3PtrFixed, uAlignment, fProt, R0Process, offSub, cbSub, pszTag);
594	#endif
595	return VERR_NOT_SUPPORTED;
596	}
597
598
599	int rtR0MemObjNativeProtect(PRTR0MEMOBJINTERNAL pMem, size_t offSub, size_t cbSub, uint32_t fProt)
600	{
601	return VERR_NOT_SUPPORTED;
602	}
603
604
605	RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
606	{
607	PRTR0MEMOBJHAIKU pMemHaiku = (PRTR0MEMOBJHAIKU)pMem;
608	status_t rc;
609
610	/** @todo r=ramshankar: Validate objects */
611
612	LogFlow(("rtR0MemObjNativeGetPagePhysAddr: pMem=%p enmType=%x iPage=%u\n", pMem, pMemHaiku->Core.enmType,(unsigned)iPage));
613
614	switch (pMemHaiku->Core.enmType)
615	{
616	case RTR0MEMOBJTYPE_LOCK:
617	{
618	team_id TeamId = B_SYSTEM_TEAM;
619	physical_entry aPhysMap[2];
620	int32 cPhysMap = 2; /** @todo r=ramshankar: why not use RT_ELEMENTS? */
621
622	if (pMemHaiku->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
623	TeamId = (team_id)pMemHaiku->Core.u.Lock.R0Process;
624	void *pb = pMemHaiku->Core.pv + (iPage << PAGE_SHIFT);
625
626	rc = get_memory_map_etc(TeamId, pb, B_PAGE_SIZE, aPhysMap, &cPhysMap);
627	if (rc < B_OK \|\| cPhysMap < 1)
628	return NIL_RTHCPHYS;
629
630	return aPhysMap[0].address;
631	}
632
633	#if 0
634	case RTR0MEMOBJTYPE_MAPPING:
635	{
636	vm_offset_t pb = (vm_offset_t)pMemHaiku->Core.pv + (iPage << PAGE_SHIFT);
637
638	if (pMemHaiku->Core.u.Mapping.R0Process != NIL_RTR0PROCESS)
639	{
640	struct proc pProc = (struct proc )pMemHaiku->Core.u.Mapping.R0Process;
641	struct vm_map *pProcMap = &pProc->p_vmspace->vm_map;
642	pmap_t pPhysicalMap = pProcMap->pmap;
643
644	return pmap_extract(pPhysicalMap, pb);
645	}
646	return vtophys(pb);
647	}
648	#endif
649	case RTR0MEMOBJTYPE_CONT:
650	return pMemHaiku->Core.u.Cont.Phys + (iPage << PAGE_SHIFT);
651
652	case RTR0MEMOBJTYPE_PHYS:
653	return pMemHaiku->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);
654
655	case RTR0MEMOBJTYPE_LOW:
656	case RTR0MEMOBJTYPE_PAGE:
657	case RTR0MEMOBJTYPE_PHYS_NC:
658	{
659	team_id TeamId = B_SYSTEM_TEAM;
660	physical_entry aPhysMap[2];
661	int32 cPhysMap = 2; /** @todo r=ramshankar: why not use RT_ELEMENTS? */
662
663	void *pb = pMemHaiku->Core.pv + (iPage << PAGE_SHIFT);
664	rc = get_memory_map_etc(TeamId, pb, B_PAGE_SIZE, aPhysMap, &cPhysMap);
665	if (rc < B_OK \|\| cPhysMap < 1)
666	return NIL_RTHCPHYS;
667
668	return aPhysMap[0].address;
669	}
670
671	case RTR0MEMOBJTYPE_RES_VIRT:
672	default:
673	return NIL_RTHCPHYS;
674	}
675	}
676

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

source: vbox/trunk/src/VBox/Runtime/r0drv/haiku/memobj-r0drv-haiku.c@ 92258

Download in other formats: