VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/alloc.cpp@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 5 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 8.7 KB
Line 
1/* $Id: alloc.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * IPRT - Memory Allocation.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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* Defined Constants And Macros *
30*********************************************************************************************************************************/
31#if defined(RTMEM_WRAP_TO_EF_APIS) && !defined(RTMEM_NO_WRAP_TO_EF_APIS)
32# undef RTMEM_WRAP_TO_EF_APIS
33# define RTALLOC_USE_EFENCE 1
34#endif
35
36/*#define RTMEMALLOC_USE_TRACKER*/
37/* Don't enable the tracker when building the minimal IPRT. */
38#ifdef RT_MINI
39# undef RTMEMALLOC_USE_TRACKER
40#endif
41
42#if defined(RTMEMALLOC_USE_TRACKER) && defined(RTALLOC_USE_EFENCE)
43# error "Cannot define both RTMEMALLOC_USE_TRACKER and RTALLOC_USE_EFENCE!"
44#endif
45
46
47/*********************************************************************************************************************************
48* Header Files *
49*********************************************************************************************************************************/
50#include "alloc-ef.h"
51#include <iprt/mem.h>
52
53#include <iprt/asm.h>
54#include <iprt/assert.h>
55#ifdef RTMEMALLOC_USE_TRACKER
56# include <iprt/memtracker.h>
57#endif
58#include <iprt/param.h>
59#include <iprt/string.h>
60#include "internal/mem.h"
61
62#include <stdlib.h>
63
64#undef RTMemTmpAlloc
65#undef RTMemTmpAllocTag
66#undef RTMemTmpAllocZ
67#undef RTMemTmpAllocZTag
68#undef RTMemTmpFree
69#undef RTMemAlloc
70#undef RTMemAllocTag
71#undef RTMemAllocZ
72#undef RTMemAllocZTag
73#undef RTMemAllocVar
74#undef RTMemAllocVarTag
75#undef RTMemAllocZVar
76#undef RTMemAllocZVarTag
77#undef RTMemRealloc
78#undef RTMemReallocTag
79#undef RTMemFree
80#undef RTMemDup
81#undef RTMemDupTag
82#undef RTMemDupEx
83#undef RTMemDupExTag
84
85#undef RTALLOC_USE_EFENCE
86
87
88#ifdef IPRT_WITH_GCC_SANITIZER
89/**
90 * Checks if @a pszTag is a leak tag.
91 *
92 * @returns true if leak tag, false if not.
93 * @param pszTag Tage to inspect.
94 */
95DECLINLINE(bool) rtMemIsLeakTag(const char *pszTag)
96{
97 char ch = *pszTag;
98 if (ch != 'w')
99 { /* likely */ }
100 else
101 return pszTag[1] == 'i'
102 && pszTag[2] == 'l'
103 && pszTag[3] == 'l'
104 && pszTag[4] == '-'
105 && pszTag[5] == 'l'
106 && pszTag[6] == 'e'
107 && pszTag[7] == 'a'
108 && pszTag[8] == 'k';
109 if (ch != 'm')
110 return false;
111 return pszTag[1] == 'm'
112 && pszTag[2] == 'a'
113 && pszTag[3] == 'y'
114 && pszTag[4] == '-'
115 && pszTag[5] == 'l'
116 && pszTag[6] == 'e'
117 && pszTag[7] == 'a'
118 && pszTag[8] == 'k';
119}
120#endif /* IPRT_WITH_GCC_SANITIZER */
121
122
123RTDECL(void *) RTMemTmpAllocTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF
124{
125 return RTMemAllocTag(cb, pszTag);
126}
127
128
129RTDECL(void *) RTMemTmpAllocZTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF
130{
131 return RTMemAllocZTag(cb, pszTag);
132}
133
134
135RTDECL(void) RTMemTmpFree(void *pv) RT_NO_THROW_DEF
136{
137 RTMemFree(pv);
138}
139
140
141RTDECL(void *) RTMemAllocTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF
142{
143#ifdef RTALLOC_USE_EFENCE
144 void *pv = rtR3MemAlloc("Alloc", RTMEMTYPE_RTMEMALLOC, cb, cb, pszTag, ASMReturnAddress(), NULL, 0, NULL);
145
146#else /* !RTALLOC_USE_EFENCE */
147
148 AssertMsg(cb, ("Allocating ZERO bytes is really not a good idea! Good luck with the next assertion!\n"));
149# ifdef RTMEMALLOC_USE_TRACKER
150 void *pv = RTMemTrackerHdrAlloc(malloc(cb + sizeof(RTMEMTRACKERHDR)), cb, pszTag, ASMReturnAddress(), RTMEMTRACKERMETHOD_ALLOC);
151# else
152 void *pv = malloc(cb); NOREF(pszTag);
153# endif
154 AssertMsg(pv, ("malloc(%#zx) failed!!!\n", cb));
155 AssertMsg( cb < RTMEM_ALIGNMENT
156 || !((uintptr_t)pv & (RTMEM_ALIGNMENT - 1))
157 || ( (cb & RTMEM_ALIGNMENT) + ((uintptr_t)pv & RTMEM_ALIGNMENT)) == RTMEM_ALIGNMENT
158 , ("pv=%p RTMEM_ALIGNMENT=%#x\n", pv, RTMEM_ALIGNMENT));
159#endif /* !RTALLOC_USE_EFENCE */
160#ifdef IPRT_WITH_GCC_SANITIZER
161 if (rtMemIsLeakTag(pszTag))
162 __lsan_ignore_object(pv);
163#endif
164 return pv;
165}
166
167
168RTDECL(void *) RTMemAllocZTag(size_t cb, const char *pszTag) RT_NO_THROW_DEF
169{
170#ifdef RTALLOC_USE_EFENCE
171 void *pv = rtR3MemAlloc("AllocZ", RTMEMTYPE_RTMEMALLOCZ, cb, cb, pszTag, ASMReturnAddress(), NULL, 0, NULL);
172
173#else /* !RTALLOC_USE_EFENCE */
174
175 AssertMsg(cb, ("Allocating ZERO bytes is really not a good idea! Good luck with the next assertion!\n"));
176
177# ifdef RTMEMALLOC_USE_TRACKER
178 void *pv = RTMemTrackerHdrAlloc(calloc(1, cb + sizeof(RTMEMTRACKERHDR)), cb, pszTag, ASMReturnAddress(), RTMEMTRACKERMETHOD_ALLOCZ);
179#else
180 void *pv = calloc(1, cb); NOREF(pszTag);
181#endif
182 AssertMsg(pv, ("calloc(1,%#zx) failed!!!\n", cb));
183 AssertMsg( cb < RTMEM_ALIGNMENT
184 || !((uintptr_t)pv & (RTMEM_ALIGNMENT - 1))
185 || ( (cb & RTMEM_ALIGNMENT) + ((uintptr_t)pv & RTMEM_ALIGNMENT)) == RTMEM_ALIGNMENT
186 , ("pv=%p RTMEM_ALIGNMENT=%#x\n", pv, RTMEM_ALIGNMENT));
187#endif /* !RTALLOC_USE_EFENCE */
188#ifdef IPRT_WITH_GCC_SANITIZER
189 if (rtMemIsLeakTag(pszTag))
190 __lsan_ignore_object(pv);
191#endif
192 return pv;
193}
194
195
196RTDECL(void *) RTMemAllocVarTag(size_t cbUnaligned, const char *pszTag) RT_NO_THROW_DEF
197{
198 size_t cbAligned;
199 if (cbUnaligned >= 16)
200 cbAligned = RT_ALIGN_Z(cbUnaligned, 16);
201 else
202 cbAligned = RT_ALIGN_Z(cbUnaligned, sizeof(void *));
203#ifdef RTALLOC_USE_EFENCE
204 void *pv = rtR3MemAlloc("AllocVar", RTMEMTYPE_RTMEMALLOC, cbUnaligned, cbAligned, pszTag, ASMReturnAddress(), NULL, 0, NULL);
205#else
206 void *pv = RTMemAllocTag(cbAligned, pszTag);
207#endif
208 return pv;
209}
210
211
212RTDECL(void *) RTMemAllocZVarTag(size_t cbUnaligned, const char *pszTag) RT_NO_THROW_DEF
213{
214 size_t cbAligned;
215 if (cbUnaligned >= 16)
216 cbAligned = RT_ALIGN_Z(cbUnaligned, 16);
217 else
218 cbAligned = RT_ALIGN_Z(cbUnaligned, sizeof(void *));
219#ifdef RTALLOC_USE_EFENCE
220 void *pv = rtR3MemAlloc("AllocZVar", RTMEMTYPE_RTMEMALLOCZ, cbUnaligned, cbAligned, pszTag, ASMReturnAddress(), NULL, 0, NULL);
221#else
222 void *pv = RTMemAllocZTag(cbAligned, pszTag);
223#endif
224 return pv;
225}
226
227
228RTDECL(void *) RTMemReallocTag(void *pvOld, size_t cbNew, const char *pszTag) RT_NO_THROW_DEF
229{
230#ifdef RTALLOC_USE_EFENCE
231 void *pv = rtR3MemRealloc("Realloc", RTMEMTYPE_RTMEMREALLOC, pvOld, cbNew, pszTag, ASMReturnAddress(), NULL, 0, NULL);
232
233#else /* !RTALLOC_USE_EFENCE */
234
235# ifdef RTMEMALLOC_USE_TRACKER
236 void *pvRealOld = RTMemTrackerHdrReallocPrep(pvOld, 0, pszTag, ASMReturnAddress());
237 size_t cbRealNew = cbNew || !pvRealOld ? cbNew + sizeof(RTMEMTRACKERHDR) : 0;
238 void *pvNew = realloc(pvRealOld, cbRealNew);
239 void *pv = RTMemTrackerHdrReallocDone(pvNew, cbNew, pvOld, pszTag, ASMReturnAddress());
240# else
241 void *pv = realloc(pvOld, cbNew); NOREF(pszTag);
242# endif
243 AssertMsg(pv || !cbNew, ("realloc(%p, %#zx) failed!!!\n", pvOld, cbNew));
244 AssertMsg( cbNew < RTMEM_ALIGNMENT
245 || !((uintptr_t)pv & (RTMEM_ALIGNMENT - 1))
246 || ( (cbNew & RTMEM_ALIGNMENT) + ((uintptr_t)pv & RTMEM_ALIGNMENT)) == RTMEM_ALIGNMENT
247 , ("pv=%p RTMEM_ALIGNMENT=%#x\n", pv, RTMEM_ALIGNMENT));
248#endif /* !RTALLOC_USE_EFENCE */
249 return pv;
250}
251
252
253RTDECL(void) RTMemFree(void *pv) RT_NO_THROW_DEF
254{
255 if (pv)
256#ifdef RTALLOC_USE_EFENCE
257 rtR3MemFree("Free", RTMEMTYPE_RTMEMFREE, pv, ASMReturnAddress(), NULL, 0, NULL);
258#else
259# ifdef RTMEMALLOC_USE_TRACKER
260 pv = RTMemTrackerHdrFree(pv, 0, NULL, ASMReturnAddress(), RTMEMTRACKERMETHOD_FREE);
261# endif
262 free(pv);
263#endif
264}
265
266
267
268DECLHIDDEN(void *) rtMemBaseAlloc(size_t cb)
269{
270 Assert(cb > 0 && cb < _1M);
271 return malloc(cb);
272}
273
274
275DECLHIDDEN(void) rtMemBaseFree(void *pv)
276{
277 free(pv);
278}
279
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use