?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm/hmm.c: remove superfluous RCU protection around radix tree lookup
[linux/fpc-iii.git] / drivers / acpi / acpica / uttrack.c
blob016a6621cc6faca0bbe56665bdef358a2bcbc8b9
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3 *
4 * Module Name: uttrack - Memory allocation tracking routines (debug only)
5 *
6 * Copyright (C) 2000 - 2018, Intel Corp.
7 *
8 *****************************************************************************/
9
10 /*
11 * These procedures are used for tracking memory leaks in the subsystem, and
12 * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
13 *
14 * Each memory allocation is tracked via a doubly linked list. Each
15 * element contains the caller's component, module name, function name, and
16 * line number. acpi_ut_allocate and acpi_ut_allocate_zeroed call
17 * acpi_ut_track_allocation to add an element to the list; deletion
18 * occurs in the body of acpi_ut_free.
19 */
20
21 #include <acpi/acpi.h>
22 #include "accommon.h"
23
24 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
25
26 #define _COMPONENT ACPI_UTILITIES
27 ACPI_MODULE_NAME("uttrack")
28
29 /* Local prototypes */
30 static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
31 acpi_debug_mem_block
32 *allocation);
33
34 static acpi_status
35 acpi_ut_track_allocation(struct acpi_debug_mem_block *address,
36 acpi_size size,
37 u8 alloc_type,
38 u32 component, const char *module, u32 line);
39
40 static acpi_status
41 acpi_ut_remove_allocation(struct acpi_debug_mem_block *address,
42 u32 component, const char *module, u32 line);
43
44 /*******************************************************************************
45 *
46 * FUNCTION: acpi_ut_create_list
47 *
48 * PARAMETERS: cache_name - Ascii name for the cache
49 * object_size - Size of each cached object
50 * return_cache - Where the new cache object is returned
51 *
52 * RETURN: Status
53 *
54 * DESCRIPTION: Create a local memory list for tracking purposed
55 *
56 ******************************************************************************/
57
58 acpi_status
59 acpi_ut_create_list(const char *list_name,
60 u16 object_size, struct acpi_memory_list **return_cache)
61 {
62 struct acpi_memory_list *cache;
63
64 cache = acpi_os_allocate_zeroed(sizeof(struct acpi_memory_list));
65 if (!cache) {
66 return (AE_NO_MEMORY);
67 }
68
69 cache->list_name = list_name;
70 cache->object_size = object_size;
71
72 *return_cache = cache;
73 return (AE_OK);
74 }
75
76 /*******************************************************************************
77 *
78 * FUNCTION: acpi_ut_allocate_and_track
79 *
80 * PARAMETERS: size - Size of the allocation
81 * component - Component type of caller
82 * module - Source file name of caller
83 * line - Line number of caller
84 *
85 * RETURN: Address of the allocated memory on success, NULL on failure.
86 *
87 * DESCRIPTION: The subsystem's equivalent of malloc.
88 *
89 ******************************************************************************/
90
91 void *acpi_ut_allocate_and_track(acpi_size size,
92 u32 component, const char *module, u32 line)
93 {
94 struct acpi_debug_mem_block *allocation;
95 acpi_status status;
96
97 /* Check for an inadvertent size of zero bytes */
98
99 if (!size) {
100 ACPI_WARNING((module, line,
101 "Attempt to allocate zero bytes, allocating 1 byte"));
102 size = 1;
103 }
104
105 allocation =
106 acpi_os_allocate(size + sizeof(struct acpi_debug_mem_header));
107 if (!allocation) {
108
109 /* Report allocation error */
110
111 ACPI_WARNING((module, line,
112 "Could not allocate size %u", (u32)size));
113
114 return (NULL);
115 }
116
117 status =
118 acpi_ut_track_allocation(allocation, size, ACPI_MEM_MALLOC,
119 component, module, line);
120 if (ACPI_FAILURE(status)) {
121 acpi_os_free(allocation);
122 return (NULL);
123 }
124
125 acpi_gbl_global_list->total_allocated++;
126 acpi_gbl_global_list->total_size += (u32)size;
127 acpi_gbl_global_list->current_total_size += (u32)size;
128
129 if (acpi_gbl_global_list->current_total_size >
130 acpi_gbl_global_list->max_occupied) {
131 acpi_gbl_global_list->max_occupied =
132 acpi_gbl_global_list->current_total_size;
133 }
134
135 return ((void *)&allocation->user_space);
136 }
137
138 /*******************************************************************************
139 *
140 * FUNCTION: acpi_ut_allocate_zeroed_and_track
141 *
142 * PARAMETERS: size - Size of the allocation
143 * component - Component type of caller
144 * module - Source file name of caller
145 * line - Line number of caller
146 *
147 * RETURN: Address of the allocated memory on success, NULL on failure.
148 *
149 * DESCRIPTION: Subsystem equivalent of calloc.
150 *
151 ******************************************************************************/
152
153 void *acpi_ut_allocate_zeroed_and_track(acpi_size size,
154 u32 component,
155 const char *module, u32 line)
156 {
157 struct acpi_debug_mem_block *allocation;
158 acpi_status status;
159
160 /* Check for an inadvertent size of zero bytes */
161
162 if (!size) {
163 ACPI_WARNING((module, line,
164 "Attempt to allocate zero bytes, allocating 1 byte"));
165 size = 1;
166 }
167
168 allocation =
169 acpi_os_allocate_zeroed(size +
170 sizeof(struct acpi_debug_mem_header));
171 if (!allocation) {
172
173 /* Report allocation error */
174
175 ACPI_ERROR((module, line,
176 "Could not allocate size %u", (u32)size));
177 return (NULL);
178 }
179
180 status = acpi_ut_track_allocation(allocation, size,
181 ACPI_MEM_CALLOC, component, module,
182 line);
183 if (ACPI_FAILURE(status)) {
184 acpi_os_free(allocation);
185 return (NULL);
186 }
187
188 acpi_gbl_global_list->total_allocated++;
189 acpi_gbl_global_list->total_size += (u32)size;
190 acpi_gbl_global_list->current_total_size += (u32)size;
191
192 if (acpi_gbl_global_list->current_total_size >
193 acpi_gbl_global_list->max_occupied) {
194 acpi_gbl_global_list->max_occupied =
195 acpi_gbl_global_list->current_total_size;
196 }
197
198 return ((void *)&allocation->user_space);
199 }
200
201 /*******************************************************************************
202 *
203 * FUNCTION: acpi_ut_free_and_track
204 *
205 * PARAMETERS: allocation - Address of the memory to deallocate
206 * component - Component type of caller
207 * module - Source file name of caller
208 * line - Line number of caller
209 *
210 * RETURN: None
211 *
212 * DESCRIPTION: Frees the memory at Allocation
213 *
214 ******************************************************************************/
215
216 void
217 acpi_ut_free_and_track(void *allocation,
218 u32 component, const char *module, u32 line)
219 {
220 struct acpi_debug_mem_block *debug_block;
221 acpi_status status;
222
223 ACPI_FUNCTION_TRACE_PTR(ut_free, allocation);
224
225 if (NULL == allocation) {
226 ACPI_ERROR((module, line, "Attempt to delete a NULL address"));
227
228 return_VOID;
229 }
230
231 debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block,
232 (((char *)allocation) -
233 sizeof(struct acpi_debug_mem_header)));
234
235 acpi_gbl_global_list->total_freed++;
236 acpi_gbl_global_list->current_total_size -= debug_block->size;
237
238 status =
239 acpi_ut_remove_allocation(debug_block, component, module, line);
240 if (ACPI_FAILURE(status)) {
241 ACPI_EXCEPTION((AE_INFO, status, "Could not free memory"));
242 }
243
244 acpi_os_free(debug_block);
245 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p freed (block %p)\n",
246 allocation, debug_block));
247 return_VOID;
248 }
249
250 /*******************************************************************************
251 *
252 * FUNCTION: acpi_ut_find_allocation
253 *
254 * PARAMETERS: allocation - Address of allocated memory
255 *
256 * RETURN: Three cases:
257 * 1) List is empty, NULL is returned.
258 * 2) Element was found. Returns Allocation parameter.
259 * 3) Element was not found. Returns position where it should be
260 * inserted into the list.
261 *
262 * DESCRIPTION: Searches for an element in the global allocation tracking list.
263 * If the element is not found, returns the location within the
264 * list where the element should be inserted.
265 *
266 * Note: The list is ordered by larger-to-smaller addresses.
267 *
268 * This global list is used to detect memory leaks in ACPICA as
269 * well as other issues such as an attempt to release the same
270 * internal object more than once. Although expensive as far
271 * as cpu time, this list is much more helpful for finding these
272 * types of issues than using memory leak detectors outside of
273 * the ACPICA code.
274 *
275 ******************************************************************************/
276
277 static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
278 acpi_debug_mem_block
279 *allocation)
280 {
281 struct acpi_debug_mem_block *element;
282
283 element = acpi_gbl_global_list->list_head;
284 if (!element) {
285 return (NULL);
286 }
287
288 /*
289 * Search for the address.
290 *
291 * Note: List is ordered by larger-to-smaller addresses, on the
292 * assumption that a new allocation usually has a larger address
293 * than previous allocations.
294 */
295 while (element > allocation) {
296
297 /* Check for end-of-list */
298
299 if (!element->next) {
300 return (element);
301 }
302
303 element = element->next;
304 }
305
306 if (element == allocation) {
307 return (element);
308 }
309
310 return (element->previous);
311 }
312
313 /*******************************************************************************
314 *
315 * FUNCTION: acpi_ut_track_allocation
316 *
317 * PARAMETERS: allocation - Address of allocated memory
318 * size - Size of the allocation
319 * alloc_type - MEM_MALLOC or MEM_CALLOC
320 * component - Component type of caller
321 * module - Source file name of caller
322 * line - Line number of caller
323 *
324 * RETURN: Status
325 *
326 * DESCRIPTION: Inserts an element into the global allocation tracking list.
327 *
328 ******************************************************************************/
329
330 static acpi_status
331 acpi_ut_track_allocation(struct acpi_debug_mem_block *allocation,
332 acpi_size size,
333 u8 alloc_type,
334 u32 component, const char *module, u32 line)
335 {
336 struct acpi_memory_list *mem_list;
337 struct acpi_debug_mem_block *element;
338 acpi_status status = AE_OK;
339
340 ACPI_FUNCTION_TRACE_PTR(ut_track_allocation, allocation);
341
342 if (acpi_gbl_disable_mem_tracking) {
343 return_ACPI_STATUS(AE_OK);
344 }
345
346 mem_list = acpi_gbl_global_list;
347 status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
348 if (ACPI_FAILURE(status)) {
349 return_ACPI_STATUS(status);
350 }
351
352 /*
353 * Search the global list for this address to make sure it is not
354 * already present. This will catch several kinds of problems.
355 */
356 element = acpi_ut_find_allocation(allocation);
357 if (element == allocation) {
358 ACPI_ERROR((AE_INFO,
359 "UtTrackAllocation: Allocation (%p) already present in global list!",
360 allocation));
361 goto unlock_and_exit;
362 }
363
364 /* Fill in the instance data */
365
366 allocation->size = (u32)size;
367 allocation->alloc_type = alloc_type;
368 allocation->component = component;
369 allocation->line = line;
370
371 acpi_ut_safe_strncpy(allocation->module, (char *)module,
372 ACPI_MAX_MODULE_NAME);
373
374 if (!element) {
375
376 /* Insert at list head */
377
378 if (mem_list->list_head) {
379 ((struct acpi_debug_mem_block *)(mem_list->list_head))->
380 previous = allocation;
381 }
382
383 allocation->next = mem_list->list_head;
384 allocation->previous = NULL;
385
386 mem_list->list_head = allocation;
387 } else {
388 /* Insert after element */
389
390 allocation->next = element->next;
391 allocation->previous = element;
392
393 if (element->next) {
394 (element->next)->previous = allocation;
395 }
396
397 element->next = allocation;
398 }
399
400 unlock_and_exit:
401 status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
402 return_ACPI_STATUS(status);
403 }
404
405 /*******************************************************************************
406 *
407 * FUNCTION: acpi_ut_remove_allocation
408 *
409 * PARAMETERS: allocation - Address of allocated memory
410 * component - Component type of caller
411 * module - Source file name of caller
412 * line - Line number of caller
413 *
414 * RETURN: Status
415 *
416 * DESCRIPTION: Deletes an element from the global allocation tracking list.
417 *
418 ******************************************************************************/
419
420 static acpi_status
421 acpi_ut_remove_allocation(struct acpi_debug_mem_block *allocation,
422 u32 component, const char *module, u32 line)
423 {
424 struct acpi_memory_list *mem_list;
425 acpi_status status;
426
427 ACPI_FUNCTION_NAME(ut_remove_allocation);
428
429 if (acpi_gbl_disable_mem_tracking) {
430 return (AE_OK);
431 }
432
433 mem_list = acpi_gbl_global_list;
434 if (NULL == mem_list->list_head) {
435
436 /* No allocations! */
437
438 ACPI_ERROR((module, line,
439 "Empty allocation list, nothing to free!"));
440
441 return (AE_OK);
442 }
443
444 status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
445 if (ACPI_FAILURE(status)) {
446 return (status);
447 }
448
449 /* Unlink */
450
451 if (allocation->previous) {
452 (allocation->previous)->next = allocation->next;
453 } else {
454 mem_list->list_head = allocation->next;
455 }
456
457 if (allocation->next) {
458 (allocation->next)->previous = allocation->previous;
459 }
460
461 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Freeing %p, size 0%X\n",
462 &allocation->user_space, allocation->size));
463
464 /* Mark the segment as deleted */
465
466 memset(&allocation->user_space, 0xEA, allocation->size);
467
468 status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
469 return (status);
470 }
471
472 /*******************************************************************************
473 *
474 * FUNCTION: acpi_ut_dump_allocation_info
475 *
476 * PARAMETERS: None
477 *
478 * RETURN: None
479 *
480 * DESCRIPTION: Print some info about the outstanding allocations.
481 *
482 ******************************************************************************/
483
484 void acpi_ut_dump_allocation_info(void)
485 {
486 /*
487 struct acpi_memory_list *mem_list;
488 */
489
490 ACPI_FUNCTION_TRACE(ut_dump_allocation_info);
491
492 /*
493 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
494 ("%30s: %4d (%3d Kb)\n", "Current allocations",
495 mem_list->current_count,
496 ROUND_UP_TO_1K (mem_list->current_size)));
497
498 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
499 ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
500 mem_list->max_concurrent_count,
501 ROUND_UP_TO_1K (mem_list->max_concurrent_size)));
502
503 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
504 ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
505 running_object_count,
506 ROUND_UP_TO_1K (running_object_size)));
507
508 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
509 ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
510 running_alloc_count,
511 ROUND_UP_TO_1K (running_alloc_size)));
512
513 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
514 ("%30s: %4d (%3d Kb)\n", "Current Nodes",
515 acpi_gbl_current_node_count,
516 ROUND_UP_TO_1K (acpi_gbl_current_node_size)));
517
518 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
519 ("%30s: %4d (%3d Kb)\n", "Max Nodes",
520 acpi_gbl_max_concurrent_node_count,
521 ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count *
522 sizeof (struct acpi_namespace_node)))));
523 */
524 return_VOID;
525 }
526
527 /*******************************************************************************
528 *
529 * FUNCTION: acpi_ut_dump_allocations
530 *
531 * PARAMETERS: component - Component(s) to dump info for.
532 * module - Module to dump info for. NULL means all.
533 *
534 * RETURN: None
535 *
536 * DESCRIPTION: Print a list of all outstanding allocations.
537 *
538 ******************************************************************************/
539
540 void acpi_ut_dump_allocations(u32 component, const char *module)
541 {
542 struct acpi_debug_mem_block *element;
543 union acpi_descriptor *descriptor;
544 u32 num_outstanding = 0;
545 u8 descriptor_type;
546
547 ACPI_FUNCTION_TRACE(ut_dump_allocations);
548
549 if (acpi_gbl_disable_mem_tracking) {
550 return_VOID;
551 }
552
553 /*
554 * Walk the allocation list.
555 */
556 if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) {
557 return_VOID;
558 }
559
560 if (!acpi_gbl_global_list) {
561 goto exit;
562 }
563
564 element = acpi_gbl_global_list->list_head;
565 while (element) {
566 if ((element->component & component) &&
567 ((module == NULL)
568 || (0 == strcmp(module, element->module)))) {
569 descriptor =
570 ACPI_CAST_PTR(union acpi_descriptor,
571 &element->user_space);
572
573 if (element->size <
574 sizeof(struct acpi_common_descriptor)) {
575 acpi_os_printf("%p Length 0x%04X %9.9s-%4.4u "
576 "[Not a Descriptor - too small]\n",
577 descriptor, element->size,
578 element->module, element->line);
579 } else {
580 /* Ignore allocated objects that are in a cache */
581
582 if (ACPI_GET_DESCRIPTOR_TYPE(descriptor) !=
583 ACPI_DESC_TYPE_CACHED) {
584 acpi_os_printf
585 ("%p Length 0x%04X %9.9s-%4.4u [%s] ",
586 descriptor, element->size,
587 element->module, element->line,
588 acpi_ut_get_descriptor_name
589 (descriptor));
590
591 /* Validate the descriptor type using Type field and length */
592
593 descriptor_type = 0; /* Not a valid descriptor type */
594
595 switch (ACPI_GET_DESCRIPTOR_TYPE
596 (descriptor)) {
597 case ACPI_DESC_TYPE_OPERAND:
598
599 if (element->size ==
600 sizeof(union
601 acpi_operand_object))
602 {
603 descriptor_type =
604 ACPI_DESC_TYPE_OPERAND;
605 }
606 break;
607
608 case ACPI_DESC_TYPE_PARSER:
609
610 if (element->size ==
611 sizeof(union
612 acpi_parse_object)) {
613 descriptor_type =
614 ACPI_DESC_TYPE_PARSER;
615 }
616 break;
617
618 case ACPI_DESC_TYPE_NAMED:
619
620 if (element->size ==
621 sizeof(struct
622 acpi_namespace_node))
623 {
624 descriptor_type =
625 ACPI_DESC_TYPE_NAMED;
626 }
627 break;
628
629 default:
630
631 break;
632 }
633
634 /* Display additional info for the major descriptor types */
635
636 switch (descriptor_type) {
637 case ACPI_DESC_TYPE_OPERAND:
638
639 acpi_os_printf
640 ("%12.12s RefCount 0x%04X\n",
641 acpi_ut_get_type_name
642 (descriptor->object.common.
643 type),
644 descriptor->object.common.
645 reference_count);
646 break;
647
648 case ACPI_DESC_TYPE_PARSER:
649
650 acpi_os_printf
651 ("AmlOpcode 0x%04hX\n",
652 descriptor->op.asl.
653 aml_opcode);
654 break;
655
656 case ACPI_DESC_TYPE_NAMED:
657
658 acpi_os_printf("%4.4s\n",
659 acpi_ut_get_node_name
660 (&descriptor->
661 node));
662 break;
663
664 default:
665
666 acpi_os_printf("\n");
667 break;
668 }
669 }
670 }
671
672 num_outstanding++;
673 }
674
675 element = element->next;
676 }
677
678 exit:
679 (void)acpi_ut_release_mutex(ACPI_MTX_MEMORY);
680
681 /* Print summary */
682
683 if (!num_outstanding) {
684 ACPI_INFO(("No outstanding allocations"));
685 } else {
686 ACPI_ERROR((AE_INFO, "%u (0x%X) Outstanding cache allocations",
687 num_outstanding, num_outstanding));
688 }
689
690 return_VOID;
691 }
692
693 #endif /* ACPI_DBG_TRACK_ALLOCATIONS */
Linux with added FPC-III support