1/******************************************************************************
2 *
3 * Module Name: utcache - local cache allocation routines
4 *
5 *****************************************************************************/
6
| 1/******************************************************************************
2 *
3 * Module Name: utcache - local cache allocation routines
4 *
5 *****************************************************************************/
6
|
7/******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
| 7/*
8 * Copyright (C) 2000 - 2011, Intel Corp.
|
12 * All rights reserved.
13 *
| 9 * All rights reserved.
10 *
|
14 * 2. License
| 11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
|
15 *
| 25 *
|
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
| 26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
|
20 *
| 29 *
|
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************/
| 30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
|
115
116#define __UTCACHE_C__
117
118#include <contrib/dev/acpica/include/acpi.h>
119#include <contrib/dev/acpica/include/accommon.h>
120
121#define _COMPONENT ACPI_UTILITIES
122 ACPI_MODULE_NAME ("utcache")
123
124
125#ifdef ACPI_USE_LOCAL_CACHE
126/*******************************************************************************
127 *
128 * FUNCTION: AcpiOsCreateCache
129 *
130 * PARAMETERS: CacheName - Ascii name for the cache
131 * ObjectSize - Size of each cached object
132 * MaxDepth - Maximum depth of the cache (in objects)
133 * ReturnCache - Where the new cache object is returned
134 *
135 * RETURN: Status
136 *
137 * DESCRIPTION: Create a cache object
138 *
139 ******************************************************************************/
140
141ACPI_STATUS
142AcpiOsCreateCache (
143 char *CacheName,
144 UINT16 ObjectSize,
145 UINT16 MaxDepth,
146 ACPI_MEMORY_LIST **ReturnCache)
147{
148 ACPI_MEMORY_LIST *Cache;
149
150
151 ACPI_FUNCTION_ENTRY ();
152
153
154 if (!CacheName || !ReturnCache || (ObjectSize < 16))
155 {
156 return (AE_BAD_PARAMETER);
157 }
158
159 /* Create the cache object */
160
161 Cache = AcpiOsAllocate (sizeof (ACPI_MEMORY_LIST));
162 if (!Cache)
163 {
164 return (AE_NO_MEMORY);
165 }
166
167 /* Populate the cache object and return it */
168
169 ACPI_MEMSET (Cache, 0, sizeof (ACPI_MEMORY_LIST));
170 Cache->LinkOffset = 8;
171 Cache->ListName = CacheName;
172 Cache->ObjectSize = ObjectSize;
173 Cache->MaxDepth = MaxDepth;
174
175 *ReturnCache = Cache;
176 return (AE_OK);
177}
178
179
180/*******************************************************************************
181 *
182 * FUNCTION: AcpiOsPurgeCache
183 *
184 * PARAMETERS: Cache - Handle to cache object
185 *
186 * RETURN: Status
187 *
188 * DESCRIPTION: Free all objects within the requested cache.
189 *
190 ******************************************************************************/
191
192ACPI_STATUS
193AcpiOsPurgeCache (
194 ACPI_MEMORY_LIST *Cache)
195{
196 char *Next;
197 ACPI_STATUS Status;
198
199
200 ACPI_FUNCTION_ENTRY ();
201
202
203 if (!Cache)
204 {
205 return (AE_BAD_PARAMETER);
206 }
207
208 Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
209 if (ACPI_FAILURE (Status))
210 {
211 return (Status);
212 }
213
214 /* Walk the list of objects in this cache */
215
216 while (Cache->ListHead)
217 {
218 /* Delete and unlink one cached state object */
219
220 Next = *(ACPI_CAST_INDIRECT_PTR (char,
221 &(((char *) Cache->ListHead)[Cache->LinkOffset])));
222 ACPI_FREE (Cache->ListHead);
223
224 Cache->ListHead = Next;
225 Cache->CurrentDepth--;
226 }
227
228 (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES);
229 return (AE_OK);
230}
231
232
233/*******************************************************************************
234 *
235 * FUNCTION: AcpiOsDeleteCache
236 *
237 * PARAMETERS: Cache - Handle to cache object
238 *
239 * RETURN: Status
240 *
241 * DESCRIPTION: Free all objects within the requested cache and delete the
242 * cache object.
243 *
244 ******************************************************************************/
245
246ACPI_STATUS
247AcpiOsDeleteCache (
248 ACPI_MEMORY_LIST *Cache)
249{
250 ACPI_STATUS Status;
251
252
253 ACPI_FUNCTION_ENTRY ();
254
255
256 /* Purge all objects in the cache */
257
258 Status = AcpiOsPurgeCache (Cache);
259 if (ACPI_FAILURE (Status))
260 {
261 return (Status);
262 }
263
264 /* Now we can delete the cache object */
265
266 AcpiOsFree (Cache);
267 return (AE_OK);
268}
269
270
271/*******************************************************************************
272 *
273 * FUNCTION: AcpiOsReleaseObject
274 *
275 * PARAMETERS: Cache - Handle to cache object
276 * Object - The object to be released
277 *
278 * RETURN: None
279 *
280 * DESCRIPTION: Release an object to the specified cache. If cache is full,
281 * the object is deleted.
282 *
283 ******************************************************************************/
284
285ACPI_STATUS
286AcpiOsReleaseObject (
287 ACPI_MEMORY_LIST *Cache,
288 void *Object)
289{
290 ACPI_STATUS Status;
291
292
293 ACPI_FUNCTION_ENTRY ();
294
295
296 if (!Cache || !Object)
297 {
298 return (AE_BAD_PARAMETER);
299 }
300
301 /* If cache is full, just free this object */
302
303 if (Cache->CurrentDepth >= Cache->MaxDepth)
304 {
305 ACPI_FREE (Object);
306 ACPI_MEM_TRACKING (Cache->TotalFreed++);
307 }
308
309 /* Otherwise put this object back into the cache */
310
311 else
312 {
313 Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
314 if (ACPI_FAILURE (Status))
315 {
316 return (Status);
317 }
318
319 /* Mark the object as cached */
320
321 ACPI_MEMSET (Object, 0xCA, Cache->ObjectSize);
322 ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_CACHED);
323
324 /* Put the object at the head of the cache list */
325
326 * (ACPI_CAST_INDIRECT_PTR (char,
327 &(((char *) Object)[Cache->LinkOffset]))) = Cache->ListHead;
328 Cache->ListHead = Object;
329 Cache->CurrentDepth++;
330
331 (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES);
332 }
333
334 return (AE_OK);
335}
336
337
338/*******************************************************************************
339 *
340 * FUNCTION: AcpiOsAcquireObject
341 *
342 * PARAMETERS: Cache - Handle to cache object
343 *
344 * RETURN: the acquired object. NULL on error
345 *
346 * DESCRIPTION: Get an object from the specified cache. If cache is empty,
347 * the object is allocated.
348 *
349 ******************************************************************************/
350
351void *
352AcpiOsAcquireObject (
353 ACPI_MEMORY_LIST *Cache)
354{
355 ACPI_STATUS Status;
356 void *Object;
357
358
359 ACPI_FUNCTION_NAME (OsAcquireObject);
360
361
362 if (!Cache)
363 {
364 return (NULL);
365 }
366
367 Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
368 if (ACPI_FAILURE (Status))
369 {
370 return (NULL);
371 }
372
373 ACPI_MEM_TRACKING (Cache->Requests++);
374
375 /* Check the cache first */
376
377 if (Cache->ListHead)
378 {
379 /* There is an object available, use it */
380
381 Object = Cache->ListHead;
382 Cache->ListHead = *(ACPI_CAST_INDIRECT_PTR (char,
383 &(((char *) Object)[Cache->LinkOffset])));
384
385 Cache->CurrentDepth--;
386
387 ACPI_MEM_TRACKING (Cache->Hits++);
388 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
389 "Object %p from %s cache\n", Object, Cache->ListName));
390
391 Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);
392 if (ACPI_FAILURE (Status))
393 {
394 return (NULL);
395 }
396
397 /* Clear (zero) the previously used Object */
398
399 ACPI_MEMSET (Object, 0, Cache->ObjectSize);
400 }
401 else
402 {
403 /* The cache is empty, create a new object */
404
405 ACPI_MEM_TRACKING (Cache->TotalAllocated++);
406
407#ifdef ACPI_DBG_TRACK_ALLOCATIONS
408 if ((Cache->TotalAllocated - Cache->TotalFreed) > Cache->MaxOccupied)
409 {
410 Cache->MaxOccupied = Cache->TotalAllocated - Cache->TotalFreed;
411 }
412#endif
413
414 /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */
415
416 Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);
417 if (ACPI_FAILURE (Status))
418 {
419 return (NULL);
420 }
421
422 Object = ACPI_ALLOCATE_ZEROED (Cache->ObjectSize);
423 if (!Object)
424 {
425 return (NULL);
426 }
427 }
428
429 return (Object);
430}
431#endif /* ACPI_USE_LOCAL_CACHE */
432
433
| 43
44#define __UTCACHE_C__
45
46#include <contrib/dev/acpica/include/acpi.h>
47#include <contrib/dev/acpica/include/accommon.h>
48
49#define _COMPONENT ACPI_UTILITIES
50 ACPI_MODULE_NAME ("utcache")
51
52
53#ifdef ACPI_USE_LOCAL_CACHE
54/*******************************************************************************
55 *
56 * FUNCTION: AcpiOsCreateCache
57 *
58 * PARAMETERS: CacheName - Ascii name for the cache
59 * ObjectSize - Size of each cached object
60 * MaxDepth - Maximum depth of the cache (in objects)
61 * ReturnCache - Where the new cache object is returned
62 *
63 * RETURN: Status
64 *
65 * DESCRIPTION: Create a cache object
66 *
67 ******************************************************************************/
68
69ACPI_STATUS
70AcpiOsCreateCache (
71 char *CacheName,
72 UINT16 ObjectSize,
73 UINT16 MaxDepth,
74 ACPI_MEMORY_LIST **ReturnCache)
75{
76 ACPI_MEMORY_LIST *Cache;
77
78
79 ACPI_FUNCTION_ENTRY ();
80
81
82 if (!CacheName || !ReturnCache || (ObjectSize < 16))
83 {
84 return (AE_BAD_PARAMETER);
85 }
86
87 /* Create the cache object */
88
89 Cache = AcpiOsAllocate (sizeof (ACPI_MEMORY_LIST));
90 if (!Cache)
91 {
92 return (AE_NO_MEMORY);
93 }
94
95 /* Populate the cache object and return it */
96
97 ACPI_MEMSET (Cache, 0, sizeof (ACPI_MEMORY_LIST));
98 Cache->LinkOffset = 8;
99 Cache->ListName = CacheName;
100 Cache->ObjectSize = ObjectSize;
101 Cache->MaxDepth = MaxDepth;
102
103 *ReturnCache = Cache;
104 return (AE_OK);
105}
106
107
108/*******************************************************************************
109 *
110 * FUNCTION: AcpiOsPurgeCache
111 *
112 * PARAMETERS: Cache - Handle to cache object
113 *
114 * RETURN: Status
115 *
116 * DESCRIPTION: Free all objects within the requested cache.
117 *
118 ******************************************************************************/
119
120ACPI_STATUS
121AcpiOsPurgeCache (
122 ACPI_MEMORY_LIST *Cache)
123{
124 char *Next;
125 ACPI_STATUS Status;
126
127
128 ACPI_FUNCTION_ENTRY ();
129
130
131 if (!Cache)
132 {
133 return (AE_BAD_PARAMETER);
134 }
135
136 Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
137 if (ACPI_FAILURE (Status))
138 {
139 return (Status);
140 }
141
142 /* Walk the list of objects in this cache */
143
144 while (Cache->ListHead)
145 {
146 /* Delete and unlink one cached state object */
147
148 Next = *(ACPI_CAST_INDIRECT_PTR (char,
149 &(((char *) Cache->ListHead)[Cache->LinkOffset])));
150 ACPI_FREE (Cache->ListHead);
151
152 Cache->ListHead = Next;
153 Cache->CurrentDepth--;
154 }
155
156 (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES);
157 return (AE_OK);
158}
159
160
161/*******************************************************************************
162 *
163 * FUNCTION: AcpiOsDeleteCache
164 *
165 * PARAMETERS: Cache - Handle to cache object
166 *
167 * RETURN: Status
168 *
169 * DESCRIPTION: Free all objects within the requested cache and delete the
170 * cache object.
171 *
172 ******************************************************************************/
173
174ACPI_STATUS
175AcpiOsDeleteCache (
176 ACPI_MEMORY_LIST *Cache)
177{
178 ACPI_STATUS Status;
179
180
181 ACPI_FUNCTION_ENTRY ();
182
183
184 /* Purge all objects in the cache */
185
186 Status = AcpiOsPurgeCache (Cache);
187 if (ACPI_FAILURE (Status))
188 {
189 return (Status);
190 }
191
192 /* Now we can delete the cache object */
193
194 AcpiOsFree (Cache);
195 return (AE_OK);
196}
197
198
199/*******************************************************************************
200 *
201 * FUNCTION: AcpiOsReleaseObject
202 *
203 * PARAMETERS: Cache - Handle to cache object
204 * Object - The object to be released
205 *
206 * RETURN: None
207 *
208 * DESCRIPTION: Release an object to the specified cache. If cache is full,
209 * the object is deleted.
210 *
211 ******************************************************************************/
212
213ACPI_STATUS
214AcpiOsReleaseObject (
215 ACPI_MEMORY_LIST *Cache,
216 void *Object)
217{
218 ACPI_STATUS Status;
219
220
221 ACPI_FUNCTION_ENTRY ();
222
223
224 if (!Cache || !Object)
225 {
226 return (AE_BAD_PARAMETER);
227 }
228
229 /* If cache is full, just free this object */
230
231 if (Cache->CurrentDepth >= Cache->MaxDepth)
232 {
233 ACPI_FREE (Object);
234 ACPI_MEM_TRACKING (Cache->TotalFreed++);
235 }
236
237 /* Otherwise put this object back into the cache */
238
239 else
240 {
241 Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
242 if (ACPI_FAILURE (Status))
243 {
244 return (Status);
245 }
246
247 /* Mark the object as cached */
248
249 ACPI_MEMSET (Object, 0xCA, Cache->ObjectSize);
250 ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_CACHED);
251
252 /* Put the object at the head of the cache list */
253
254 * (ACPI_CAST_INDIRECT_PTR (char,
255 &(((char *) Object)[Cache->LinkOffset]))) = Cache->ListHead;
256 Cache->ListHead = Object;
257 Cache->CurrentDepth++;
258
259 (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES);
260 }
261
262 return (AE_OK);
263}
264
265
266/*******************************************************************************
267 *
268 * FUNCTION: AcpiOsAcquireObject
269 *
270 * PARAMETERS: Cache - Handle to cache object
271 *
272 * RETURN: the acquired object. NULL on error
273 *
274 * DESCRIPTION: Get an object from the specified cache. If cache is empty,
275 * the object is allocated.
276 *
277 ******************************************************************************/
278
279void *
280AcpiOsAcquireObject (
281 ACPI_MEMORY_LIST *Cache)
282{
283 ACPI_STATUS Status;
284 void *Object;
285
286
287 ACPI_FUNCTION_NAME (OsAcquireObject);
288
289
290 if (!Cache)
291 {
292 return (NULL);
293 }
294
295 Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);
296 if (ACPI_FAILURE (Status))
297 {
298 return (NULL);
299 }
300
301 ACPI_MEM_TRACKING (Cache->Requests++);
302
303 /* Check the cache first */
304
305 if (Cache->ListHead)
306 {
307 /* There is an object available, use it */
308
309 Object = Cache->ListHead;
310 Cache->ListHead = *(ACPI_CAST_INDIRECT_PTR (char,
311 &(((char *) Object)[Cache->LinkOffset])));
312
313 Cache->CurrentDepth--;
314
315 ACPI_MEM_TRACKING (Cache->Hits++);
316 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
317 "Object %p from %s cache\n", Object, Cache->ListName));
318
319 Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);
320 if (ACPI_FAILURE (Status))
321 {
322 return (NULL);
323 }
324
325 /* Clear (zero) the previously used Object */
326
327 ACPI_MEMSET (Object, 0, Cache->ObjectSize);
328 }
329 else
330 {
331 /* The cache is empty, create a new object */
332
333 ACPI_MEM_TRACKING (Cache->TotalAllocated++);
334
335#ifdef ACPI_DBG_TRACK_ALLOCATIONS
336 if ((Cache->TotalAllocated - Cache->TotalFreed) > Cache->MaxOccupied)
337 {
338 Cache->MaxOccupied = Cache->TotalAllocated - Cache->TotalFreed;
339 }
340#endif
341
342 /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */
343
344 Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);
345 if (ACPI_FAILURE (Status))
346 {
347 return (NULL);
348 }
349
350 Object = ACPI_ALLOCATE_ZEROED (Cache->ObjectSize);
351 if (!Object)
352 {
353 return (NULL);
354 }
355 }
356
357 return (Object);
358}
359#endif /* ACPI_USE_LOCAL_CACHE */
360
361
|