]>
Commit | Line | Data |
---|---|---|
95857638 | 1 | // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
6d33b6be LZ |
2 | /****************************************************************************** |
3 | * | |
4 | * Module Name: utcache - local cache allocation routines | |
5 | * | |
da6f8320 | 6 | * Copyright (C) 2000 - 2018, Intel Corp. |
6d33b6be | 7 | * |
95857638 | 8 | *****************************************************************************/ |
6d33b6be LZ |
9 | |
10 | #include <acpi/acpi.h> | |
11 | #include "accommon.h" | |
12 | ||
13 | #define _COMPONENT ACPI_UTILITIES | |
14 | ACPI_MODULE_NAME("utcache") | |
15 | ||
16 | #ifdef ACPI_USE_LOCAL_CACHE | |
17 | /******************************************************************************* | |
18 | * | |
19 | * FUNCTION: acpi_os_create_cache | |
20 | * | |
21 | * PARAMETERS: cache_name - Ascii name for the cache | |
22 | * object_size - Size of each cached object | |
23 | * max_depth - Maximum depth of the cache (in objects) | |
24 | * return_cache - Where the new cache object is returned | |
25 | * | |
26 | * RETURN: Status | |
27 | * | |
28 | * DESCRIPTION: Create a cache object | |
29 | * | |
30 | ******************************************************************************/ | |
31 | acpi_status | |
32 | acpi_os_create_cache(char *cache_name, | |
33 | u16 object_size, | |
cd27d79f | 34 | u16 max_depth, struct acpi_memory_list **return_cache) |
6d33b6be LZ |
35 | { |
36 | struct acpi_memory_list *cache; | |
37 | ||
38 | ACPI_FUNCTION_ENTRY(); | |
39 | ||
c8e8ab1e | 40 | if (!cache_name || !return_cache || !object_size) { |
6d33b6be LZ |
41 | return (AE_BAD_PARAMETER); |
42 | } | |
43 | ||
44 | /* Create the cache object */ | |
45 | ||
46 | cache = acpi_os_allocate(sizeof(struct acpi_memory_list)); | |
47 | if (!cache) { | |
48 | return (AE_NO_MEMORY); | |
49 | } | |
50 | ||
51 | /* Populate the cache object and return it */ | |
52 | ||
4fa4616e | 53 | memset(cache, 0, sizeof(struct acpi_memory_list)); |
6d33b6be LZ |
54 | cache->list_name = cache_name; |
55 | cache->object_size = object_size; | |
56 | cache->max_depth = max_depth; | |
57 | ||
58 | *return_cache = cache; | |
59 | return (AE_OK); | |
60 | } | |
61 | ||
62 | /******************************************************************************* | |
63 | * | |
64 | * FUNCTION: acpi_os_purge_cache | |
65 | * | |
66 | * PARAMETERS: cache - Handle to cache object | |
67 | * | |
68 | * RETURN: Status | |
69 | * | |
70 | * DESCRIPTION: Free all objects within the requested cache. | |
71 | * | |
72 | ******************************************************************************/ | |
73 | ||
f5c1e1c5 | 74 | acpi_status acpi_os_purge_cache(struct acpi_memory_list *cache) |
6d33b6be | 75 | { |
3cf24497 | 76 | void *next; |
6d33b6be LZ |
77 | acpi_status status; |
78 | ||
79 | ACPI_FUNCTION_ENTRY(); | |
80 | ||
81 | if (!cache) { | |
82 | return (AE_BAD_PARAMETER); | |
83 | } | |
84 | ||
85 | status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); | |
86 | if (ACPI_FAILURE(status)) { | |
87 | return (status); | |
88 | } | |
89 | ||
90 | /* Walk the list of objects in this cache */ | |
91 | ||
92 | while (cache->list_head) { | |
93 | ||
94 | /* Delete and unlink one cached state object */ | |
95 | ||
1af89271 | 96 | next = ACPI_GET_DESCRIPTOR_PTR(cache->list_head); |
6d33b6be LZ |
97 | ACPI_FREE(cache->list_head); |
98 | ||
99 | cache->list_head = next; | |
100 | cache->current_depth--; | |
101 | } | |
102 | ||
103 | (void)acpi_ut_release_mutex(ACPI_MTX_CACHES); | |
104 | return (AE_OK); | |
105 | } | |
106 | ||
107 | /******************************************************************************* | |
108 | * | |
109 | * FUNCTION: acpi_os_delete_cache | |
110 | * | |
111 | * PARAMETERS: cache - Handle to cache object | |
112 | * | |
113 | * RETURN: Status | |
114 | * | |
115 | * DESCRIPTION: Free all objects within the requested cache and delete the | |
116 | * cache object. | |
117 | * | |
118 | ******************************************************************************/ | |
119 | ||
f5c1e1c5 | 120 | acpi_status acpi_os_delete_cache(struct acpi_memory_list *cache) |
6d33b6be LZ |
121 | { |
122 | acpi_status status; | |
123 | ||
124 | ACPI_FUNCTION_ENTRY(); | |
125 | ||
126 | /* Purge all objects in the cache */ | |
127 | ||
128 | status = acpi_os_purge_cache(cache); | |
129 | if (ACPI_FAILURE(status)) { | |
130 | return (status); | |
131 | } | |
132 | ||
133 | /* Now we can delete the cache object */ | |
134 | ||
135 | acpi_os_free(cache); | |
136 | return (AE_OK); | |
137 | } | |
138 | ||
139 | /******************************************************************************* | |
140 | * | |
141 | * FUNCTION: acpi_os_release_object | |
142 | * | |
143 | * PARAMETERS: cache - Handle to cache object | |
144 | * object - The object to be released | |
145 | * | |
146 | * RETURN: None | |
147 | * | |
73a3090a | 148 | * DESCRIPTION: Release an object to the specified cache. If cache is full, |
6d33b6be LZ |
149 | * the object is deleted. |
150 | * | |
151 | ******************************************************************************/ | |
152 | ||
f5c1e1c5 | 153 | acpi_status acpi_os_release_object(struct acpi_memory_list *cache, void *object) |
6d33b6be LZ |
154 | { |
155 | acpi_status status; | |
156 | ||
157 | ACPI_FUNCTION_ENTRY(); | |
158 | ||
159 | if (!cache || !object) { | |
160 | return (AE_BAD_PARAMETER); | |
161 | } | |
162 | ||
163 | /* If cache is full, just free this object */ | |
164 | ||
165 | if (cache->current_depth >= cache->max_depth) { | |
166 | ACPI_FREE(object); | |
167 | ACPI_MEM_TRACKING(cache->total_freed++); | |
168 | } | |
169 | ||
170 | /* Otherwise put this object back into the cache */ | |
171 | ||
172 | else { | |
173 | status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); | |
174 | if (ACPI_FAILURE(status)) { | |
175 | return (status); | |
176 | } | |
177 | ||
178 | /* Mark the object as cached */ | |
179 | ||
4fa4616e | 180 | memset(object, 0xCA, cache->object_size); |
6d33b6be LZ |
181 | ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_CACHED); |
182 | ||
183 | /* Put the object at the head of the cache list */ | |
184 | ||
1af89271 | 185 | ACPI_SET_DESCRIPTOR_PTR(object, cache->list_head); |
6d33b6be LZ |
186 | cache->list_head = object; |
187 | cache->current_depth++; | |
188 | ||
189 | (void)acpi_ut_release_mutex(ACPI_MTX_CACHES); | |
190 | } | |
191 | ||
192 | return (AE_OK); | |
193 | } | |
194 | ||
195 | /******************************************************************************* | |
196 | * | |
197 | * FUNCTION: acpi_os_acquire_object | |
198 | * | |
199 | * PARAMETERS: cache - Handle to cache object | |
200 | * | |
73a3090a | 201 | * RETURN: the acquired object. NULL on error |
6d33b6be | 202 | * |
73a3090a | 203 | * DESCRIPTION: Get an object from the specified cache. If cache is empty, |
6d33b6be LZ |
204 | * the object is allocated. |
205 | * | |
206 | ******************************************************************************/ | |
207 | ||
208 | void *acpi_os_acquire_object(struct acpi_memory_list *cache) | |
209 | { | |
210 | acpi_status status; | |
211 | void *object; | |
212 | ||
1e059e20 | 213 | ACPI_FUNCTION_TRACE(os_acquire_object); |
6d33b6be LZ |
214 | |
215 | if (!cache) { | |
5076f005 | 216 | return_PTR(NULL); |
6d33b6be LZ |
217 | } |
218 | ||
219 | status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); | |
220 | if (ACPI_FAILURE(status)) { | |
5076f005 | 221 | return_PTR(NULL); |
6d33b6be LZ |
222 | } |
223 | ||
224 | ACPI_MEM_TRACKING(cache->requests++); | |
225 | ||
226 | /* Check the cache first */ | |
227 | ||
228 | if (cache->list_head) { | |
229 | ||
230 | /* There is an object available, use it */ | |
231 | ||
232 | object = cache->list_head; | |
1af89271 | 233 | cache->list_head = ACPI_GET_DESCRIPTOR_PTR(object); |
6d33b6be LZ |
234 | |
235 | cache->current_depth--; | |
236 | ||
237 | ACPI_MEM_TRACKING(cache->hits++); | |
1ef63231 BM |
238 | ACPI_DEBUG_PRINT_RAW((ACPI_DB_EXEC, |
239 | "%s: Object %p from %s cache\n", | |
240 | ACPI_GET_FUNCTION_NAME, object, | |
241 | cache->list_name)); | |
6d33b6be LZ |
242 | |
243 | status = acpi_ut_release_mutex(ACPI_MTX_CACHES); | |
244 | if (ACPI_FAILURE(status)) { | |
5076f005 | 245 | return_PTR(NULL); |
6d33b6be LZ |
246 | } |
247 | ||
248 | /* Clear (zero) the previously used Object */ | |
249 | ||
4fa4616e | 250 | memset(object, 0, cache->object_size); |
6d33b6be LZ |
251 | } else { |
252 | /* The cache is empty, create a new object */ | |
253 | ||
254 | ACPI_MEM_TRACKING(cache->total_allocated++); | |
255 | ||
256 | #ifdef ACPI_DBG_TRACK_ALLOCATIONS | |
257 | if ((cache->total_allocated - cache->total_freed) > | |
258 | cache->max_occupied) { | |
259 | cache->max_occupied = | |
260 | cache->total_allocated - cache->total_freed; | |
261 | } | |
262 | #endif | |
263 | ||
264 | /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */ | |
265 | ||
266 | status = acpi_ut_release_mutex(ACPI_MTX_CACHES); | |
267 | if (ACPI_FAILURE(status)) { | |
5076f005 | 268 | return_PTR(NULL); |
6d33b6be LZ |
269 | } |
270 | ||
271 | object = ACPI_ALLOCATE_ZEROED(cache->object_size); | |
272 | if (!object) { | |
5076f005 | 273 | return_PTR(NULL); |
6d33b6be LZ |
274 | } |
275 | } | |
276 | ||
5076f005 | 277 | return_PTR(object); |
6d33b6be LZ |
278 | } |
279 | #endif /* ACPI_USE_LOCAL_CACHE */ |