VirtualBox

source: vbox/trunk/src/VBox/Runtime/r0drv/linux/alloc-r0drv-linux.c@ 29945

Last change on this file since 29945 was 28800, checked in by vboxsync, 15 years ago

Automated rebranding to Oracle copyright/license strings via filemuncher
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 9.5 KB
Line 
1/* $Id: alloc-r0drv-linux.c 28800 2010-04-27 08:22:32Z vboxsync $ */
2/** @file
3 * IPRT - Memory Allocation, Ring-0 Driver, Linux.
4 */
5
6/*
7 * Copyright (C) 2006-2007 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-linux-kernel.h"
32#include "internal/iprt.h"
33
34#include <iprt/mem.h>
35#include <iprt/assert.h>
36#include "r0drv/alloc-r0drv.h"
37
38#if defined(RT_ARCH_AMD64) || defined(DOXYGEN_RUNNING)
39/**
40 * We need memory in the module range (~2GB to ~0) this can only be obtained
41 * thru APIs that are not exported (see module_alloc()).
42 *
43 * So, we'll have to create a quick and dirty heap here using BSS memory.
44 * Very annoying and it's going to restrict us!
45 */
46# define RTMEMALLOC_EXEC_HEAP
47#endif
48#ifdef RTMEMALLOC_EXEC_HEAP
49# include <iprt/heap.h>
50# include <iprt/spinlock.h>
51# include <iprt/err.h>
52#endif
53
54
55/*******************************************************************************
56* Global Variables *
57*******************************************************************************/
58#ifdef RTMEMALLOC_EXEC_HEAP
59/** The heap. */
60static RTHEAPSIMPLE g_HeapExec = NIL_RTHEAPSIMPLE;
61/** Spinlock protecting the heap. */
62static RTSPINLOCK g_HeapExecSpinlock = NIL_RTSPINLOCK;
63
64
65/**
66 * API for cleaning up the heap spinlock on IPRT termination.
67 * This is as RTMemExecDonate specific to AMD64 Linux/GNU.
68 */
69void rtR0MemExecCleanup(void)
70{
71 RTSpinlockDestroy(g_HeapExecSpinlock);
72 g_HeapExecSpinlock = NIL_RTSPINLOCK;
73}
74
75
76/**
77 * Donate read+write+execute memory to the exec heap.
78 *
79 * This API is specific to AMD64 and Linux/GNU. A kernel module that desires to
80 * use RTMemExecAlloc on AMD64 Linux/GNU will have to donate some statically
81 * allocated memory in the module if it wishes for GCC generated code to work.
82 * GCC can only generate modules that work in the address range ~2GB to ~0
83 * currently.
84 *
85 * The API only accept one single donation.
86 *
87 * @returns IPRT status code.
88 * @param pvMemory Pointer to the memory block.
89 * @param cb The size of the memory block.
90 */
91RTR0DECL(int) RTR0MemExecDonate(void *pvMemory, size_t cb)
92{
93 int rc;
94 AssertReturn(g_HeapExec == NIL_RTHEAPSIMPLE, VERR_WRONG_ORDER);
95
96 rc = RTSpinlockCreate(&g_HeapExecSpinlock);
97 if (RT_SUCCESS(rc))
98 {
99 rc = RTHeapSimpleInit(&g_HeapExec, pvMemory, cb);
100 if (RT_FAILURE(rc))
101 rtR0MemExecCleanup();
102 }
103 return rc;
104}
105RT_EXPORT_SYMBOL(RTR0MemExecDonate);
106#endif /* RTMEMALLOC_EXEC_HEAP */
107
108
109
110/**
111 * OS specific allocation function.
112 */
113PRTMEMHDR rtR0MemAlloc(size_t cb, uint32_t fFlags)
114{
115 /*
116 * Allocate.
117 */
118 PRTMEMHDR pHdr;
119 if (fFlags & RTMEMHDR_FLAG_EXEC)
120 {
121#if defined(RT_ARCH_AMD64)
122# ifdef RTMEMALLOC_EXEC_HEAP
123 if (g_HeapExec != NIL_RTHEAPSIMPLE)
124 {
125 RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
126 RTSpinlockAcquireNoInts(g_HeapExecSpinlock, &SpinlockTmp);
127 pHdr = (PRTMEMHDR)RTHeapSimpleAlloc(g_HeapExec, cb + sizeof(*pHdr), 0);
128 RTSpinlockReleaseNoInts(g_HeapExecSpinlock, &SpinlockTmp);
129 fFlags |= RTMEMHDR_FLAG_EXEC_HEAP;
130 }
131 else
132 pHdr = NULL;
133# else /* !RTMEMALLOC_EXEC_HEAP */
134 pHdr = (PRTMEMHDR)__vmalloc(cb + sizeof(*pHdr), GFP_KERNEL | __GFP_HIGHMEM, MY_PAGE_KERNEL_EXEC);
135# endif /* !RTMEMALLOC_EXEC_HEAP */
136
137#elif defined(PAGE_KERNEL_EXEC) && defined(CONFIG_X86_PAE)
138 pHdr = (PRTMEMHDR)__vmalloc(cb + sizeof(*pHdr), GFP_KERNEL | __GFP_HIGHMEM, MY_PAGE_KERNEL_EXEC);
139#else
140 pHdr = (PRTMEMHDR)vmalloc(cb + sizeof(*pHdr));
141#endif
142 }
143 else
144 {
145 if (cb <= PAGE_SIZE)
146 {
147 fFlags |= RTMEMHDR_FLAG_KMALLOC;
148 pHdr = kmalloc(cb + sizeof(*pHdr), GFP_KERNEL);
149 }
150 else
151 pHdr = vmalloc(cb + sizeof(*pHdr));
152 }
153
154 /*
155 * Initialize.
156 */
157 if (pHdr)
158 {
159 pHdr->u32Magic = RTMEMHDR_MAGIC;
160 pHdr->fFlags = fFlags;
161 pHdr->cb = cb;
162 pHdr->cbReq = cb;
163 }
164 return pHdr;
165}
166
167
168/**
169 * OS specific free function.
170 */
171void rtR0MemFree(PRTMEMHDR pHdr)
172{
173 pHdr->u32Magic += 1;
174 if (pHdr->fFlags & RTMEMHDR_FLAG_KMALLOC)
175 kfree(pHdr);
176#ifdef RTMEMALLOC_EXEC_HEAP
177 else if (pHdr->fFlags & RTMEMHDR_FLAG_EXEC_HEAP)
178 {
179 RTSPINLOCKTMP SpinlockTmp = RTSPINLOCKTMP_INITIALIZER;
180 RTSpinlockAcquireNoInts(g_HeapExecSpinlock, &SpinlockTmp);
181 RTHeapSimpleFree(g_HeapExec, pHdr);
182 RTSpinlockReleaseNoInts(g_HeapExecSpinlock, &SpinlockTmp);
183 }
184#endif
185 else
186 vfree(pHdr);
187}
188
189
190/**
191 * Compute order. Some functions allocate 2^order pages.
192 *
193 * @returns order.
194 * @param cPages Number of pages.
195 */
196static int CalcPowerOf2Order(unsigned long cPages)
197{
198 int iOrder;
199 unsigned long cTmp;
200
201 for (iOrder = 0, cTmp = cPages; cTmp >>= 1; ++iOrder)
202 ;
203 if (cPages & ~(1 << iOrder))
204 ++iOrder;
205
206 return iOrder;
207}
208
209
210/**
211 * Allocates physical contiguous memory (below 4GB).
212 * The allocation is page aligned and the content is undefined.
213 *
214 * @returns Pointer to the memory block. This is page aligned.
215 * @param pPhys Where to store the physical address.
216 * @param cb The allocation size in bytes. This is always
217 * rounded up to PAGE_SIZE.
218 */
219RTR0DECL(void *) RTMemContAlloc(PRTCCPHYS pPhys, size_t cb)
220{
221 int cOrder;
222 unsigned cPages;
223 struct page *paPages;
224
225 /*
226 * validate input.
227 */
228 Assert(VALID_PTR(pPhys));
229 Assert(cb > 0);
230
231 /*
232 * Allocate page pointer array.
233 */
234 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
235 cPages = cb >> PAGE_SHIFT;
236 cOrder = CalcPowerOf2Order(cPages);
237#if (defined(RT_ARCH_AMD64) || defined(CONFIG_X86_PAE)) && defined(GFP_DMA32)
238 /* ZONE_DMA32: 0-4GB */
239 paPages = alloc_pages(GFP_DMA32, cOrder);
240 if (!paPages)
241#endif
242#ifdef RT_ARCH_AMD64
243 /* ZONE_DMA; 0-16MB */
244 paPages = alloc_pages(GFP_DMA, cOrder);
245#else
246 /* ZONE_NORMAL: 0-896MB */
247 paPages = alloc_pages(GFP_USER, cOrder);
248#endif
249 if (paPages)
250 {
251 /*
252 * Reserve the pages and mark them executable.
253 */
254 unsigned iPage;
255 for (iPage = 0; iPage < cPages; iPage++)
256 {
257 Assert(!PageHighMem(&paPages[iPage]));
258 if (iPage + 1 < cPages)
259 {
260 AssertMsg( (uintptr_t)phys_to_virt(page_to_phys(&paPages[iPage])) + PAGE_SIZE
261 == (uintptr_t)phys_to_virt(page_to_phys(&paPages[iPage + 1]))
262 && page_to_phys(&paPages[iPage]) + PAGE_SIZE
263 == page_to_phys(&paPages[iPage + 1]),
264 ("iPage=%i cPages=%u [0]=%#llx,%p [1]=%#llx,%p\n", iPage, cPages,
265 (long long)page_to_phys(&paPages[iPage]), phys_to_virt(page_to_phys(&paPages[iPage])),
266 (long long)page_to_phys(&paPages[iPage + 1]), phys_to_virt(page_to_phys(&paPages[iPage + 1])) ));
267 }
268
269 SetPageReserved(&paPages[iPage]);
270#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 4, 20) /** @todo find the exact kernel where change_page_attr was introduced. */
271 MY_SET_PAGES_EXEC(&paPages[iPage], 1);
272#endif
273 }
274 *pPhys = page_to_phys(paPages);
275 return phys_to_virt(page_to_phys(paPages));
276 }
277
278 return NULL;
279}
280RT_EXPORT_SYMBOL(RTMemContAlloc);
281
282
283/**
284 * Frees memory allocated ysing RTMemContAlloc().
285 *
286 * @param pv Pointer to return from RTMemContAlloc().
287 * @param cb The cb parameter passed to RTMemContAlloc().
288 */
289RTR0DECL(void) RTMemContFree(void *pv, size_t cb)
290{
291 if (pv)
292 {
293 int cOrder;
294 unsigned cPages;
295 unsigned iPage;
296 struct page *paPages;
297
298 /* validate */
299 AssertMsg(!((uintptr_t)pv & PAGE_OFFSET_MASK), ("pv=%p\n", pv));
300 Assert(cb > 0);
301
302 /* calc order and get pages */
303 cb = RT_ALIGN_Z(cb, PAGE_SIZE);
304 cPages = cb >> PAGE_SHIFT;
305 cOrder = CalcPowerOf2Order(cPages);
306 paPages = virt_to_page(pv);
307
308 /*
309 * Restore page attributes freeing the pages.
310 */
311 for (iPage = 0; iPage < cPages; iPage++)
312 {
313 ClearPageReserved(&paPages[iPage]);
314#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 4, 20) /** @todo find the exact kernel where change_page_attr was introduced. */
315 MY_SET_PAGES_NOEXEC(&paPages[iPage], 1);
316#endif
317 }
318 __free_pages(paPages, cOrder);
319 }
320}
321RT_EXPORT_SYMBOL(RTMemContFree);
322
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