xref: /linux/drivers/acpi/acpica/utalloc.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: utalloc - local memory allocation routines
5  *
6  * Copyright (C) 2000 - 2023, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "acdebug.h"
13 
14 #define _COMPONENT          ACPI_UTILITIES
15 ACPI_MODULE_NAME("utalloc")
16 
17 #if !defined (USE_NATIVE_ALLOCATE_ZEROED)
18 /*******************************************************************************
19  *
20  * FUNCTION:    acpi_os_allocate_zeroed
21  *
22  * PARAMETERS:  size                - Size of the allocation
23  *
24  * RETURN:      Address of the allocated memory on success, NULL on failure.
25  *
26  * DESCRIPTION: Subsystem equivalent of calloc. Allocate and zero memory.
27  *              This is the default implementation. Can be overridden via the
28  *              USE_NATIVE_ALLOCATE_ZEROED flag.
29  *
30  ******************************************************************************/
acpi_os_allocate_zeroed(acpi_size size)31 void *acpi_os_allocate_zeroed(acpi_size size)
32 {
33 	void *allocation;
34 
35 	ACPI_FUNCTION_ENTRY();
36 
37 	allocation = acpi_os_allocate(size);
38 	if (allocation) {
39 
40 		/* Clear the memory block */
41 
42 		memset(allocation, 0, size);
43 	}
44 
45 	return (allocation);
46 }
47 
48 #endif				/* !USE_NATIVE_ALLOCATE_ZEROED */
49 
50 /*******************************************************************************
51  *
52  * FUNCTION:    acpi_ut_create_caches
53  *
54  * PARAMETERS:  None
55  *
56  * RETURN:      Status
57  *
58  * DESCRIPTION: Create all local caches
59  *
60  ******************************************************************************/
61 
acpi_ut_create_caches(void)62 acpi_status acpi_ut_create_caches(void)
63 {
64 	acpi_status status;
65 
66 	/* Object Caches, for frequently used objects */
67 
68 	status =
69 	    acpi_os_create_cache("Acpi-Namespace",
70 				 sizeof(struct acpi_namespace_node),
71 				 ACPI_MAX_NAMESPACE_CACHE_DEPTH,
72 				 &acpi_gbl_namespace_cache);
73 	if (ACPI_FAILURE(status)) {
74 		return (status);
75 	}
76 
77 	status =
78 	    acpi_os_create_cache("Acpi-State", sizeof(union acpi_generic_state),
79 				 ACPI_MAX_STATE_CACHE_DEPTH,
80 				 &acpi_gbl_state_cache);
81 	if (ACPI_FAILURE(status)) {
82 		return (status);
83 	}
84 
85 	status =
86 	    acpi_os_create_cache("Acpi-Parse",
87 				 sizeof(struct acpi_parse_obj_common),
88 				 ACPI_MAX_PARSE_CACHE_DEPTH,
89 				 &acpi_gbl_ps_node_cache);
90 	if (ACPI_FAILURE(status)) {
91 		return (status);
92 	}
93 
94 	status =
95 	    acpi_os_create_cache("Acpi-ParseExt",
96 				 sizeof(struct acpi_parse_obj_named),
97 				 ACPI_MAX_EXTPARSE_CACHE_DEPTH,
98 				 &acpi_gbl_ps_node_ext_cache);
99 	if (ACPI_FAILURE(status)) {
100 		return (status);
101 	}
102 
103 	status =
104 	    acpi_os_create_cache("Acpi-Operand",
105 				 sizeof(union acpi_operand_object),
106 				 ACPI_MAX_OBJECT_CACHE_DEPTH,
107 				 &acpi_gbl_operand_cache);
108 	if (ACPI_FAILURE(status)) {
109 		return (status);
110 	}
111 #ifdef ACPI_ASL_COMPILER
112 	/*
113 	 * For use with the ASL-/ASL+ option. This cache keeps track of regular
114 	 * 0xA9 0x01 comments.
115 	 */
116 	status =
117 	    acpi_os_create_cache("Acpi-Comment",
118 				 sizeof(struct acpi_comment_node),
119 				 ACPI_MAX_COMMENT_CACHE_DEPTH,
120 				 &acpi_gbl_reg_comment_cache);
121 	if (ACPI_FAILURE(status)) {
122 		return (status);
123 	}
124 
125 	/*
126 	 * This cache keeps track of the starting addresses of where the comments
127 	 * lie. This helps prevent duplication of comments.
128 	 */
129 	status =
130 	    acpi_os_create_cache("Acpi-Comment-Addr",
131 				 sizeof(struct acpi_comment_addr_node),
132 				 ACPI_MAX_COMMENT_CACHE_DEPTH,
133 				 &acpi_gbl_comment_addr_cache);
134 	if (ACPI_FAILURE(status)) {
135 		return (status);
136 	}
137 
138 	/*
139 	 * This cache will be used for nodes that represent files.
140 	 */
141 	status =
142 	    acpi_os_create_cache("Acpi-File", sizeof(struct acpi_file_node),
143 				 ACPI_MAX_COMMENT_CACHE_DEPTH,
144 				 &acpi_gbl_file_cache);
145 	if (ACPI_FAILURE(status)) {
146 		return (status);
147 	}
148 #endif
149 
150 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
151 
152 	/* Memory allocation lists */
153 
154 	status = acpi_ut_create_list("Acpi-Global", 0, &acpi_gbl_global_list);
155 	if (ACPI_FAILURE(status)) {
156 		return (status);
157 	}
158 
159 	status =
160 	    acpi_ut_create_list("Acpi-Namespace",
161 				sizeof(struct acpi_namespace_node),
162 				&acpi_gbl_ns_node_list);
163 	if (ACPI_FAILURE(status)) {
164 		return (status);
165 	}
166 #endif
167 
168 	return (AE_OK);
169 }
170 
171 /*******************************************************************************
172  *
173  * FUNCTION:    acpi_ut_delete_caches
174  *
175  * PARAMETERS:  None
176  *
177  * RETURN:      Status
178  *
179  * DESCRIPTION: Purge and delete all local caches
180  *
181  ******************************************************************************/
182 
acpi_ut_delete_caches(void)183 acpi_status acpi_ut_delete_caches(void)
184 {
185 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
186 	char buffer[7];
187 
188 	if (acpi_gbl_display_final_mem_stats) {
189 		strcpy(buffer, "MEMORY");
190 		(void)acpi_db_display_statistics(buffer);
191 	}
192 #endif
193 
194 	(void)acpi_os_delete_cache(acpi_gbl_namespace_cache);
195 	acpi_gbl_namespace_cache = NULL;
196 
197 	(void)acpi_os_delete_cache(acpi_gbl_state_cache);
198 	acpi_gbl_state_cache = NULL;
199 
200 	(void)acpi_os_delete_cache(acpi_gbl_operand_cache);
201 	acpi_gbl_operand_cache = NULL;
202 
203 	(void)acpi_os_delete_cache(acpi_gbl_ps_node_cache);
204 	acpi_gbl_ps_node_cache = NULL;
205 
206 	(void)acpi_os_delete_cache(acpi_gbl_ps_node_ext_cache);
207 	acpi_gbl_ps_node_ext_cache = NULL;
208 
209 #ifdef ACPI_ASL_COMPILER
210 	(void)acpi_os_delete_cache(acpi_gbl_reg_comment_cache);
211 	acpi_gbl_reg_comment_cache = NULL;
212 
213 	(void)acpi_os_delete_cache(acpi_gbl_comment_addr_cache);
214 	acpi_gbl_comment_addr_cache = NULL;
215 
216 	(void)acpi_os_delete_cache(acpi_gbl_file_cache);
217 	acpi_gbl_file_cache = NULL;
218 #endif
219 
220 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
221 
222 	/* Debug only - display leftover memory allocation, if any */
223 
224 	acpi_ut_dump_allocations(ACPI_UINT32_MAX, NULL);
225 
226 	/* Free memory lists */
227 
228 	acpi_os_free(acpi_gbl_global_list);
229 	acpi_gbl_global_list = NULL;
230 
231 	acpi_os_free(acpi_gbl_ns_node_list);
232 	acpi_gbl_ns_node_list = NULL;
233 #endif
234 
235 	return (AE_OK);
236 }
237 
238 /*******************************************************************************
239  *
240  * FUNCTION:    acpi_ut_validate_buffer
241  *
242  * PARAMETERS:  buffer              - Buffer descriptor to be validated
243  *
244  * RETURN:      Status
245  *
246  * DESCRIPTION: Perform parameter validation checks on an struct acpi_buffer
247  *
248  ******************************************************************************/
249 
acpi_ut_validate_buffer(struct acpi_buffer * buffer)250 acpi_status acpi_ut_validate_buffer(struct acpi_buffer *buffer)
251 {
252 
253 	/* Obviously, the structure pointer must be valid */
254 
255 	if (!buffer) {
256 		return (AE_BAD_PARAMETER);
257 	}
258 
259 	/* Special semantics for the length */
260 
261 	if ((buffer->length == ACPI_NO_BUFFER) ||
262 	    (buffer->length == ACPI_ALLOCATE_BUFFER) ||
263 	    (buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
264 		return (AE_OK);
265 	}
266 
267 	/* Length is valid, the buffer pointer must be also */
268 
269 	if (!buffer->pointer) {
270 		return (AE_BAD_PARAMETER);
271 	}
272 
273 	return (AE_OK);
274 }
275 
276 /*******************************************************************************
277  *
278  * FUNCTION:    acpi_ut_initialize_buffer
279  *
280  * PARAMETERS:  buffer              - Buffer to be validated
281  *              required_length     - Length needed
282  *
283  * RETURN:      Status
284  *
285  * DESCRIPTION: Validate that the buffer is of the required length or
286  *              allocate a new buffer. Returned buffer is always zeroed.
287  *
288  ******************************************************************************/
289 
290 acpi_status
acpi_ut_initialize_buffer(struct acpi_buffer * buffer,acpi_size required_length)291 acpi_ut_initialize_buffer(struct acpi_buffer *buffer, acpi_size required_length)
292 {
293 	acpi_size input_buffer_length;
294 
295 	/* Parameter validation */
296 
297 	if (!buffer || !required_length) {
298 		return (AE_BAD_PARAMETER);
299 	}
300 
301 	/*
302 	 * Buffer->Length is used as both an input and output parameter. Get the
303 	 * input actual length and set the output required buffer length.
304 	 */
305 	input_buffer_length = buffer->length;
306 	buffer->length = required_length;
307 
308 	/*
309 	 * The input buffer length contains the actual buffer length, or the type
310 	 * of buffer to be allocated by this routine.
311 	 */
312 	switch (input_buffer_length) {
313 	case ACPI_NO_BUFFER:
314 
315 		/* Return the exception (and the required buffer length) */
316 
317 		return (AE_BUFFER_OVERFLOW);
318 
319 	case ACPI_ALLOCATE_BUFFER:
320 		/*
321 		 * Allocate a new buffer. We directectly call acpi_os_allocate here to
322 		 * purposefully bypass the (optionally enabled) internal allocation
323 		 * tracking mechanism since we only want to track internal
324 		 * allocations. Note: The caller should use acpi_os_free to free this
325 		 * buffer created via ACPI_ALLOCATE_BUFFER.
326 		 */
327 		buffer->pointer = acpi_os_allocate(required_length);
328 		break;
329 
330 	case ACPI_ALLOCATE_LOCAL_BUFFER:
331 
332 		/* Allocate a new buffer with local interface to allow tracking */
333 
334 		buffer->pointer = ACPI_ALLOCATE(required_length);
335 		break;
336 
337 	default:
338 
339 		/* Existing buffer: Validate the size of the buffer */
340 
341 		if (input_buffer_length < required_length) {
342 			return (AE_BUFFER_OVERFLOW);
343 		}
344 		break;
345 	}
346 
347 	/* Validate allocation from above or input buffer pointer */
348 
349 	if (!buffer->pointer) {
350 		return (AE_NO_MEMORY);
351 	}
352 
353 	/* Have a valid buffer, clear it */
354 
355 	memset(buffer->pointer, 0, required_length);
356 	return (AE_OK);
357 }
358