sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

mm: Move the real implementation of mm_sbrk to sbrk

Browse Source 
and remove mm_sbrk and kmm_sbrk since it's wrong to expose
sbrk to other heaps except the default userspace heap.

Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
This commit is contained in:
Xiang Xiao 2021-07-04 00:33:36 +08:00 committed by Masayuki Ishikawa
parent 7b20a0d789
commit ddaa3e42b9
7 changed files with 64 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
arch/sim/src/sim/up_heap.c
View File

@ -364,46 +364,6 @@ FAR void *mm_brkaddr(FAR struct mm_heap_s *heap, int region)
return NULL;
}
/****************************************************************************
* Name: mm_sbrk
*
* Description:
* The sbrk() function is used to change the amount of space allocated
* for the calling process. The change is made by resetting the process's
* break value and allocating the appropriate amount of space. The amount
* of allocated space increases as the break value increases.
*
* The sbrk() function adds 'incr' bytes to the break value and changes
* the allocated space accordingly. If incr is negative, the amount of
* allocated space is decreased by incr bytes. The current value of the
* program break is returned by sbrk(0).
*
* Input Parameters:
* heap - A reference to the data structure that defines this heap.
* incr - Specifies the number of bytes to add or to remove from the
* space allocated for the process.
* maxbreak - The maximum permissible break address.
*
* Returned Value:
* Upon successful completion, sbrk() returns the prior break value.
* Otherwise, it returns (void *)-1 and sets errno to indicate the
* error:
*
* ENOMEM - The requested change would allocate more space than
* allowed under system limits.
* EAGAIN - The total amount of system memory available for allocation
* to this process is temporarily insufficient. This may occur even
* though the space requested was less than the maximum data segment
* size.
*
****************************************************************************/
FAR void *mm_sbrk(FAR struct mm_heap_s *heap, intptr_t incr,
uintptr_t maxbreak)
{
return NULL;
}
/****************************************************************************
* Name: mm_extend
*

14
include/nuttx/mm/mm.h
View File

@ -273,20 +273,6 @@ FAR void *umm_brkaddr(int region);
FAR void *kmm_brkaddr(int region);
#endif
/* Functions contained in mm_sbrk.c *****************************************/
#if defined(CONFIG_ARCH_ADDRENV) && defined(CONFIG_MM_PGALLOC)
FAR void *mm_sbrk(FAR struct mm_heap_s *heap, intptr_t incr,
uintptr_t maxbreak);
#endif
/* Functions contained in kmm_sbrk.c ****************************************/
#if defined(CONFIG_MM_KERNEL_HEAP) && defined(CONFIG_ARCH_ADDRENV) && \
defined(CONFIG_MM_PGALLOC)
FAR void *kmm_sbrk(intptr_t incr);
#endif
/* Functions contained in mm_extend.c ***************************************/
void mm_extend(FAR struct mm_heap_s *heap, FAR void *mem, size_t size,

4
mm/kmm_heap/Make.defs
View File

@ -26,10 +26,6 @@ CSRCS += kmm_initialize.c kmm_addregion.c
CSRCS += kmm_brkaddr.c kmm_calloc.c kmm_extend.c kmm_free.c kmm_mallinfo.c
CSRCS += kmm_malloc.c kmm_memalign.c kmm_realloc.c kmm_zalloc.c kmm_heapmember.c
ifeq ($(CONFIG_BUILD_KERNEL),y)
CSRCS += kmm_sbrk.c
endif
ifeq ($(CONFIG_DEBUG_MM),y)
CSRCS += kmm_checkcorruption.c
endif

72
mm/kmm_heap/kmm_sbrk.c
View File

@ -1,72 +0,0 @@
/****************************************************************************
* mm/kmm_heap/kmm_sbrk.c
*
* 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
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/mm/mm.h>
#if defined(CONFIG_BUILD_KERNEL) && defined(__KERNEL__)
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: kmm_sbrk
*
* Description:
* The sbrk() function is used to change the amount of space allocated
* for the calling process. The change is made by resetting the process's
* break value and allocating the appropriate amount of space. The amount
* of allocated space increases as the break value increases.
*
* The sbrk() function adds 'incr' bytes to the break value and changes
* the allocated space accordingly. If incr is negative, the amount of
* allocated space is decreased by incr bytes. The current value of the
* program break is returned by sbrk(0).
*
* Input Parameters:
* incr - Specifies the number of bytes to add or to remove from the
* space allocated for the process.
*
* Returned Value:
* Upon successful completion, sbrk() returns the prior break value.
* Otherwise, it returns (void *)-1 and sets errno to indicate the
* error:
*
* ENOMEM - The requested change would allocate more space than
* allowed under system limits.
* EAGAIN - The total amount of system memory available for allocation
* to this process is temporarily insufficient. This may occur even
* though the space requested was less than the maximum data segment
* size.
*
****************************************************************************/
FAR void *kmm_sbrk(intptr_t incr)
{
return mm_sbrk(&g_kmmheap, incr, UINTPTR_MAX);
}
#endif /* CONFIG_BUILD_KERNEL && __KERNEL__ */

4
mm/mm_heap/Make.defs
View File

@ -27,10 +27,6 @@ CSRCS += mm_malloc_size.c mm_shrinkchunk.c mm_brkaddr.c mm_calloc.c
CSRCS += mm_extend.c mm_free.c mm_mallinfo.c mm_malloc.c
CSRCS += mm_memalign.c mm_realloc.c mm_zalloc.c mm_heapmember.c
ifeq ($(CONFIG_BUILD_KERNEL),y)
CSRCS += mm_sbrk.c
endif
ifeq ($(CONFIG_DEBUG_MM),y)
CSRCS += mm_checkcorruption.c
endif

149
mm/mm_heap/mm_sbrk.c
View File

@ -1,149 +0,0 @@
/****************************************************************************
* mm/mm_heap/mm_sbrk.c
*
* 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
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <assert.h>
#include <errno.h>
#include <nuttx/arch.h>
#include <nuttx/mm/mm.h>
#include <nuttx/pgalloc.h>
#ifdef CONFIG_BUILD_KERNEL
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: mm_sbrk
*
* Description:
* The sbrk() function is used to change the amount of space allocated
* for the calling process. The change is made by resetting the process's
* break value and allocating the appropriate amount of space. The amount
* of allocated space increases as the break value increases.
*
* The sbrk() function adds 'incr' bytes to the break value and changes
* the allocated space accordingly. If incr is negative, the amount of
* allocated space is decreased by incr bytes. The current value of the
* program break is returned by sbrk(0).
*
* Input Parameters:
* heap - A reference to the data structure that defines this heap.
* incr - Specifies the number of bytes to add or to remove from the
* space allocated for the process.
* maxbreak - The maximum permissible break address.
*
* Returned Value:
* Upon successful completion, sbrk() returns the prior break value.
* Otherwise, it returns (void *)-1 and sets errno to indicate the
* error:
*
* ENOMEM - The requested change would allocate more space than
* allowed under system limits.
* EAGAIN - The total amount of system memory available for allocation
* to this process is temporarily insufficient. This may occur even
* though the space requested was less than the maximum data segment
* size.
*
****************************************************************************/
FAR void *mm_sbrk(FAR struct mm_heap_s *heap, intptr_t incr,
uintptr_t maxbreak)
{
uintptr_t brkaddr;
uintptr_t allocbase;
unsigned int pgincr;
size_t bytesize;
int errcode;
DEBUGASSERT(incr >= 0);
if (incr < 0)
{
errcode = ENOSYS;
goto errout;
}
/* Get the current break address (NOTE: assumes region 0). If
* the memory manager is uninitialized, mm_brkaddr() will return
* zero.
*/
brkaddr = (uintptr_t)mm_brkaddr(heap, 0);
if (incr > 0)
{
/* Convert the increment to multiples of the page size */
pgincr = MM_NPAGES(incr);
/* Check if this increment would exceed the maximum break value */
if ((brkaddr > 0) && ((maxbreak - brkaddr) < (pgincr << MM_PGSHIFT)))
{
errcode = ENOMEM;
goto errout;
}
/* Allocate the requested number of pages and map them to the
* break address. If we provide a zero brkaddr to pgalloc(), it
* will create the first block in the correct virtual address
* space and return the start address of that block.
*/
allocbase = pgalloc(brkaddr, pgincr);
if (allocbase == 0)
{
errcode = EAGAIN;
goto errout;
}
/* Has the been been initialized? brkaddr will be zero if the
* memory manager has not yet been initialized.
*/
bytesize = pgincr << MM_PGSHIFT;
if (brkaddr == 0)
{
/* No... then initialize it now */
mm_initialize(heap, "Umem", (FAR void *)allocbase, bytesize);
}
else
{
/* Extend the heap (region 0) */
mm_extend(heap, (FAR void *)allocbase, bytesize, 0);
}
}
return (FAR void *)brkaddr;
errout:
set_errno(errcode);
return (FAR void *)-1;
}
#endif /* CONFIG_BUILD_KERNEL */

65
mm/umm_heap/umm_sbrk.c
View File

@ -24,6 +24,8 @@
#include <nuttx/config.h>
#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <nuttx/mm/mm.h>
@ -70,5 +72,66 @@
FAR void *sbrk(intptr_t incr)
{
return mm_sbrk(USR_HEAP, incr, ARCH_HEAP_VEND);
uintptr_t brkaddr;
uintptr_t allocbase;
unsigned int pgincr;
size_t bytesize;
int errcode;
DEBUGASSERT(incr >= 0);
if (incr < 0)
{
errcode = ENOSYS;
goto errout;
}
/* Get the current break address (NOTE: assumes region 0). If
* the memory manager is uninitialized, mm_brkaddr() will return
* zero.
*/
brkaddr = (uintptr_t)mm_brkaddr(USR_HEAP, 0);
if (incr > 0)
{
/* Convert the increment to multiples of the page size */
pgincr = MM_NPAGES(incr);
/* Allocate the requested number of pages and map them to the
* break address. If we provide a zero brkaddr to pgalloc(), it
* will create the first block in the correct virtual address
* space and return the start address of that block.
*/
allocbase = pgalloc(brkaddr, pgincr);
if (allocbase == 0)
{
errcode = EAGAIN;
goto errout;
}
/* Has the been been initialized? brkaddr will be zero if the
* memory manager has not yet been initialized.
*/
bytesize = pgincr << MM_PGSHIFT;
if (brkaddr == 0)
{
/* No... then initialize it now */
mm_initialize(USR_HEAP, "Umem", (FAR void *)allocbase, bytesize);
}
else
{
/* Extend the heap (region 0) */
mm_extend(USR_HEAP, (FAR void *)allocbase, bytesize, 0);
}
}
return (FAR void *)brkaddr;
errout:
set_errno(errcode);
return (FAR void *)-1;
}