2012-07-15 01:31:12 +02:00
|
|
|
/****************************************************************************
|
2014-09-22 18:53:50 +02:00
|
|
|
* mm/mm_heap/mm_free.c
|
2007-02-18 00:21:28 +01:00
|
|
|
*
|
2021-02-08 13:50:10 +01:00
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
|
|
* "License"); you may not use this file except in compliance with the
|
|
|
|
* License. You may obtain a copy of the License at
|
2007-02-18 00:21:28 +01:00
|
|
|
*
|
2021-02-08 13:50:10 +01:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2007-02-18 00:21:28 +01:00
|
|
|
*
|
2021-02-08 13:50:10 +01:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
2007-02-18 00:21:28 +01:00
|
|
|
*
|
2012-07-15 01:31:12 +02:00
|
|
|
****************************************************************************/
|
2007-02-18 00:21:28 +01:00
|
|
|
|
2012-07-15 01:31:12 +02:00
|
|
|
/****************************************************************************
|
2007-02-18 00:21:28 +01:00
|
|
|
* Included Files
|
2012-07-15 01:31:12 +02:00
|
|
|
****************************************************************************/
|
2007-02-18 00:21:28 +01:00
|
|
|
|
2013-03-08 21:36:18 +01:00
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
2007-02-18 00:21:28 +01:00
|
|
|
#include <assert.h>
|
2013-03-08 21:36:18 +01:00
|
|
|
#include <debug.h>
|
2012-07-15 01:31:12 +02:00
|
|
|
|
2020-04-07 16:21:42 +02:00
|
|
|
#include <nuttx/arch.h>
|
2014-09-24 15:29:09 +02:00
|
|
|
#include <nuttx/mm/mm.h>
|
2007-02-18 00:21:28 +01:00
|
|
|
|
2021-03-02 09:03:00 +01:00
|
|
|
#include "mm_heap/mm.h"
|
2021-10-09 09:22:28 +02:00
|
|
|
#include "kasan/kasan.h"
|
2021-03-02 09:03:00 +01:00
|
|
|
|
2020-04-07 16:21:42 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-11-06 00:19:44 +01:00
|
|
|
static void add_delaylist(FAR struct mm_heap_s *heap, FAR void *mem)
|
2020-04-07 16:21:42 +02:00
|
|
|
{
|
2021-07-07 15:21:42 +02:00
|
|
|
#if defined(CONFIG_BUILD_FLAT) || defined(__KERNEL__)
|
2020-04-10 06:32:32 +02:00
|
|
|
FAR struct mm_delaynode_s *tmp = mem;
|
2020-04-07 16:21:42 +02:00
|
|
|
irqstate_t flags;
|
|
|
|
|
|
|
|
/* Delay the deallocation until a more appropriate time. */
|
|
|
|
|
|
|
|
flags = enter_critical_section();
|
|
|
|
|
2021-07-03 16:16:25 +02:00
|
|
|
tmp->flink = heap->mm_delaylist[up_cpu_index()];
|
|
|
|
heap->mm_delaylist[up_cpu_index()] = tmp;
|
2020-04-07 16:21:42 +02:00
|
|
|
|
|
|
|
leave_critical_section(flags);
|
|
|
|
#endif
|
2021-07-07 15:21:42 +02:00
|
|
|
}
|
2020-04-07 16:21:42 +02:00
|
|
|
|
2014-08-31 18:54:55 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2012-07-15 01:31:12 +02:00
|
|
|
/****************************************************************************
|
2013-03-08 21:36:18 +01:00
|
|
|
* Name: mm_free
|
2007-02-18 00:21:28 +01:00
|
|
|
*
|
|
|
|
* Description:
|
2013-03-08 19:29:56 +01:00
|
|
|
* Returns a chunk of memory to the list of free nodes, merging with
|
2012-07-15 01:31:12 +02:00
|
|
|
* adjacent free chunks if possible.
|
2007-02-18 00:21:28 +01:00
|
|
|
*
|
2012-07-15 01:31:12 +02:00
|
|
|
****************************************************************************/
|
2007-02-18 00:21:28 +01:00
|
|
|
|
2013-03-08 21:36:18 +01:00
|
|
|
void mm_free(FAR struct mm_heap_s *heap, FAR void *mem)
|
2007-02-18 00:21:28 +01:00
|
|
|
{
|
2007-02-27 22:17:21 +01:00
|
|
|
FAR struct mm_freenode_s *node;
|
|
|
|
FAR struct mm_freenode_s *prev;
|
|
|
|
FAR struct mm_freenode_s *next;
|
2022-12-15 12:55:16 +01:00
|
|
|
size_t nodesize;
|
|
|
|
size_t prevsize;
|
2007-02-18 00:21:28 +01:00
|
|
|
|
2016-06-11 19:59:51 +02:00
|
|
|
minfo("Freeing %p\n", mem);
|
2007-03-08 19:34:11 +01:00
|
|
|
|
2007-02-18 00:21:28 +01:00
|
|
|
/* Protect against attempts to free a NULL reference */
|
|
|
|
|
|
|
|
if (!mem)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-08-04 06:10:10 +02:00
|
|
|
DEBUGASSERT(mm_heapmember(heap, mem));
|
|
|
|
|
2022-10-30 04:34:24 +01:00
|
|
|
#if CONFIG_MM_HEAP_MEMPOOL_THRESHOLD != 0
|
2022-11-23 15:08:13 +01:00
|
|
|
if (mempool_multiple_free(heap->mm_mpool, mem) >= 0)
|
2022-10-30 04:34:24 +01:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-11-05 23:44:47 +01:00
|
|
|
if (mm_lock(heap) < 0)
|
2020-04-07 16:21:42 +02:00
|
|
|
{
|
2022-02-18 06:26:08 +01:00
|
|
|
/* Meet -ESRCH return, which means we are in situations
|
2022-11-15 07:37:20 +01:00
|
|
|
* during context switching(See mm_lock() & gettid()).
|
2022-02-18 06:26:08 +01:00
|
|
|
* Then add to the delay list.
|
2020-04-10 06:32:32 +02:00
|
|
|
*/
|
2020-04-07 16:21:42 +02:00
|
|
|
|
2022-11-06 00:19:44 +01:00
|
|
|
add_delaylist(heap, mem);
|
2020-04-07 16:21:42 +02:00
|
|
|
return;
|
|
|
|
}
|
2007-02-18 00:21:28 +01:00
|
|
|
|
2022-11-24 06:46:53 +01:00
|
|
|
kasan_poison(mem, mm_malloc_size(heap, mem));
|
mm_heap/kasan: poison free node after return back the heap list
The free node is still in use after kasan_poison(), the node member
access will cause the assert report by kasan.
| (gdb) bt
| #0 kasan_report (addr=1743265406637584896, size=140737337053680, is_write=46) at kasan/kasan.c:97
| #1 0x0000555555607bdd in __asan_loadN_noabort (addr=140737272831420, size=4) at kasan/kasan.c:289
| #2 0x0000555555607cd7 in __asan_load4_noabort (addr=140737272831420) at kasan/kasan.c:323
| #3 0x00005555556061ef in gmtime_r (timep=0x7ffff3275dbc, result=0x7ffff3275e10) at time/lib_gmtimer.c:301
| #4 0x000055555560e507 in sim_rtc_rdtime (lower=0x55555576b780 <g_sim_rtc>, rtctime=0x7ffff3275e10) at sim/up_rtc.c:77
| #5 0x00005555555fcbdb in up_rtc_gettime (tp=0x7ffff3275ef0) at timers/arch_rtc.c:128
| #6 0x00005555555f08b4 in clock_systime_timespec (ts=0x7ffff3275ef0) at clock/clock_systime_timespec.c:72
| #7 0x00005555555ecc77 in note_common (tcb=0x7ffff31d2180, note=0x7ffff3275f80, length=21 '\025', type=18 '\022') at sched/sched_note.c:144
| #8 0x00005555555ed706 in sched_note_syscall_enter (nr=1, argc=0) at sched/sched_note.c:765
| #9 0x000055555560eb37 in __wrap_getpid () at wraps/WRAP_getpid.c:26
| #10 0x0000555555608d1c in mm_takesemaphore (heap=0x7ffff30ae000) at mm_heap/mm_sem.c:127
| #11 0x0000555555609477 in mm_free (heap=0x7ffff30ae000, mem=0x7ffff3265b80) at mm_heap/mm_free.c:89
| #12 0x00005555556070c5 in free (mem=0x7ffff3265b80) at umm_heap/umm_free.c:49
| #13 0x000055555560c3b0 in up_release_stack (dtcb=0x7ffff31e4b00, ttype=0 '\000') at sim/up_releasestack.c:67
| #14 0x00005555555f2515 in nxsched_release_tcb (tcb=0x7ffff31e4b00, ttype=0 '\000') at sched/sched_releasetcb.c:134
| #15 0x00005555556bdf0c in nxtask_terminate (pid=4, nonblocking=true) at task/task_terminate.c:184
| #16 0x00005555556bdb0f in nxtask_exit () at task/task_exit.c:168
| #17 0x000055555566e05f in up_exit (status=0) at sim/up_exit.c:64
| #18 0x000055555564f454 in _exit (status=0) at task/exit.c:78
| #19 0x000055555560ea89 in __wrap__exit (parm1=0) at wraps/WRAP__exit.c:27
| #20 0x00005555555eb288 in exit (status=0) at stdlib/lib_exit.c:54
| #21 0x00005555555fe2cc in nxtask_startup (entrypt=0x555555670c34 <critmon_start_main>, argc=1, argv=0x7ffff3265bb0) at sched/task_startup.c:70
| #22 0x00005555555f02a0 in nxtask_start () at task/task_start.c:134
| #23 0x0000000000000000 in ?? ()
Signed-off-by: chao.an <anchao@xiaomi.com>
2022-08-01 10:33:48 +02:00
|
|
|
|
2007-02-18 00:21:28 +01:00
|
|
|
/* Map the memory chunk into a free node */
|
|
|
|
|
2015-10-08 17:10:22 +02:00
|
|
|
node = (FAR struct mm_freenode_s *)((FAR char *)mem - SIZEOF_MM_ALLOCNODE);
|
2022-12-15 12:55:16 +01:00
|
|
|
nodesize = SIZEOF_MM_NODE(node);
|
2018-11-12 16:36:35 +01:00
|
|
|
|
|
|
|
/* Sanity check against double-frees */
|
|
|
|
|
2022-12-15 12:55:16 +01:00
|
|
|
DEBUGASSERT(node->size & MM_ALLOC_BIT);
|
2018-11-12 16:36:35 +01:00
|
|
|
|
2022-12-15 12:55:16 +01:00
|
|
|
node->size &= ~MM_ALLOC_BIT;
|
2007-02-18 00:21:28 +01:00
|
|
|
|
|
|
|
/* Check if the following node is free and, if so, merge it */
|
|
|
|
|
2022-12-15 12:55:16 +01:00
|
|
|
next = (FAR struct mm_freenode_s *)((FAR char *)node + nodesize);
|
2022-12-22 09:02:42 +01:00
|
|
|
DEBUGASSERT((next->size & MM_PREVFREE_BIT) == 0);
|
2022-12-15 12:55:16 +01:00
|
|
|
if ((next->size & MM_ALLOC_BIT) == 0)
|
2007-02-18 00:21:28 +01:00
|
|
|
{
|
2007-02-27 22:17:21 +01:00
|
|
|
FAR struct mm_allocnode_s *andbeyond;
|
2022-12-15 12:55:16 +01:00
|
|
|
size_t nextsize = SIZEOF_MM_NODE(next);
|
2007-02-18 00:21:28 +01:00
|
|
|
|
|
|
|
/* Get the node following the next node (which will
|
|
|
|
* become the new next node). We know that we can never
|
|
|
|
* index past the tail chunk because it is always allocated.
|
|
|
|
*/
|
|
|
|
|
2022-12-15 12:55:16 +01:00
|
|
|
andbeyond = (FAR struct mm_allocnode_s *)((FAR char *)next + nextsize);
|
2022-12-22 09:02:42 +01:00
|
|
|
DEBUGASSERT((andbeyond->size & MM_PREVFREE_BIT) != 0 &&
|
|
|
|
andbeyond->preceding == nextsize);
|
2007-02-18 00:21:28 +01:00
|
|
|
|
|
|
|
/* Remove the next node. There must be a predecessor,
|
|
|
|
* but there may not be a successor node.
|
|
|
|
*/
|
|
|
|
|
|
|
|
DEBUGASSERT(next->blink);
|
|
|
|
next->blink->flink = next->flink;
|
|
|
|
if (next->flink)
|
|
|
|
{
|
|
|
|
next->flink->blink = next->blink;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Then merge the two chunks */
|
|
|
|
|
2022-12-15 12:55:16 +01:00
|
|
|
nodesize += nextsize;
|
|
|
|
node->size = nodesize | (node->size & MM_MASK_BIT);
|
|
|
|
andbeyond->preceding = nodesize;
|
2007-02-27 22:17:21 +01:00
|
|
|
next = (FAR struct mm_freenode_s *)andbeyond;
|
2007-02-18 00:21:28 +01:00
|
|
|
}
|
2022-12-22 09:02:42 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
next->size |= MM_PREVFREE_BIT;
|
|
|
|
next->preceding = nodesize;
|
|
|
|
}
|
2007-02-18 00:21:28 +01:00
|
|
|
|
|
|
|
/* Check if the preceding node is also free and, if so, merge
|
|
|
|
* it with this node
|
|
|
|
*/
|
|
|
|
|
2022-12-22 09:02:42 +01:00
|
|
|
if ((node->size & MM_PREVFREE_BIT) != 0)
|
2007-02-18 00:21:28 +01:00
|
|
|
{
|
2022-12-22 09:02:42 +01:00
|
|
|
prev = (FAR struct mm_freenode_s *)
|
|
|
|
((FAR char *)node - node->preceding);
|
|
|
|
prevsize = SIZEOF_MM_NODE(prev);
|
|
|
|
DEBUGASSERT((prev->size & MM_ALLOC_BIT) == 0 &&
|
|
|
|
node->preceding == prevsize);
|
|
|
|
|
2007-02-18 00:21:28 +01:00
|
|
|
/* Remove the node. There must be a predecessor, but there may
|
|
|
|
* not be a successor node.
|
|
|
|
*/
|
|
|
|
|
|
|
|
DEBUGASSERT(prev->blink);
|
|
|
|
prev->blink->flink = prev->flink;
|
|
|
|
if (prev->flink)
|
|
|
|
{
|
|
|
|
prev->flink->blink = prev->blink;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Then merge the two chunks */
|
|
|
|
|
2022-12-15 12:55:16 +01:00
|
|
|
prevsize += nodesize;
|
|
|
|
prev->size = prevsize | (prev->size & MM_MASK_BIT);
|
|
|
|
next->preceding = prevsize;
|
2007-02-18 00:21:28 +01:00
|
|
|
node = prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the merged node to the nodelist */
|
|
|
|
|
2013-03-08 19:29:56 +01:00
|
|
|
mm_addfreechunk(heap, node);
|
2022-09-06 08:18:45 +02:00
|
|
|
mm_unlock(heap);
|
2013-03-08 19:29:56 +01:00
|
|
|
}
|