lupyuen/local-nuttx-update
1
0
Fork 0
forked from nuttx/nuttx-update
Code Pull requests Activity

Move anonymous mapping emulation into own module under fs/mmap

Browse source 
Signed-off-by: Jukka Laitinen <jukkax@ssrc.tii.ae>
This commit is contained in:
Jukka Laitinen 2023-01-09 12:02:24 +04:00 committed by Xiang Xiao
parent dd97900221
commit a5ed8014e8
5 changed files with 186 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
fs/mmap/Kconfig
View file

@ -23,5 +23,8 @@ config FS_RAMMAP
See nuttx/fs/mmap/README.txt for additional information.
if FS_RAMMAP
endif
config FS_ANONMAP
bool "Anonymous mapping emulation"
default y
---help---
Simulate private anonymous mappings by plain malloc

4
fs/mmap/Make.defs
View file

@ -24,6 +24,10 @@ ifeq ($(CONFIG_FS_RAMMAP),y)
CSRCS += fs_rammap.c
endif
ifeq ($(CONFIG_FS_ANONMAP),y)
CSRCS += fs_anonmap.c
endif
# Include MMAP build support
DEPPATH += --dep-path mmap

114
fs/mmap/fs_anonmap.c Normal file
View file

@ -0,0 +1,114 @@
/****************************************************************************
* fs/mmap/fs_anonmap.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/kmalloc.h>
#include <debug.h>
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: unmap_anonymous
****************************************************************************/
static int unmap_anonymous(FAR struct task_group_s *group,
FAR struct mm_map_entry_s *entry,
FAR void *start,
size_t length)
{
int ret;
/* De-allocate memory.
* NB: This is incomplete anounymous mapping implementation
* see file_mmap_ below
*/
if (start == entry->vaddr && length == entry->length)
{
/* entry->priv marks allocation from kernel heap */
if (entry->priv.i)
{
kmm_free(start);
}
else
{
kumm_free(start);
}
ret = mm_map_remove(get_group_mm(group), entry);
}
else
{
ret = -EINVAL;
ferr("ERROR: Unknown map type\n");
}
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
int map_anonymous(FAR struct mm_map_entry_s *entry, bool kernel)
{
int ret;
/* REVISIT: Should reside outside of the heap. That is really the
* only purpose of MAP_ANONYMOUS: To get non-heap memory. In KERNEL
* build, this could be accomplished using pgalloc(), provided that
* you had logic in place to assign a virtual address to the mapping.
*/
entry->vaddr = kernel ?
kmm_zalloc(entry->length) : kumm_zalloc(entry->length);
if (entry->vaddr == NULL)
{
ferr("ERROR: kumm_alloc() failed, enable DEBUG_MM for info!\n");
return -ENOMEM;
}
entry->munmap = unmap_anonymous;
entry->priv.i = kernel;
ret = mm_map_add(entry);
if (ret < 0)
{
if (kernel)
{
kmm_free(entry->vaddr);
}
else
{
kumm_free(entry->vaddr);
}
entry->vaddr = NULL;
}
return ret;
}

61
fs/mmap/fs_anonmap.h Normal file
View file

@ -0,0 +1,61 @@
/****************************************************************************
* fs/mmap/fs_anonmap.h
*
* 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.
*
****************************************************************************/
#ifndef __FS_MMAP_FS_ANONMAP_H
#define __FS_MMAP_FS_ANONMAP_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <nuttx/mm/map.h>
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/****************************************************************************
* Name: map_anonymous
*
* Description:
* Support simulation of private anonymous mapping by allocating memory
* from heap
*
* Input Parameters:
* map Input struct containing user request
* kernel kmm_zalloc or kumm_zalloc
*
* Returned Value:
* On success returns 0. Otherwise negated errno is returned appropriately.
*
* ENOMEM
* Insufficient memory is available to simulate mapping
*
****************************************************************************/
#ifdef CONFIG_FS_ANONMAP
int map_anonymous(FAR struct mm_map_entry_s *entry, bool kernel);
#else
#define map_anonymous(entry,kernel) (-ENOSYS)
#endif /* CONFIG_FS_ANONMAP */
#endif /* __FS_MMAP_FS_ANONMAP_H */

61
fs/mmap/fs_mmap.c
View file

@ -36,51 +36,12 @@
#include "inode/inode.h"
#include "fs_rammap.h"
#include "fs_anonmap.h"
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: unmap_anonymous
****************************************************************************/
static int unmap_anonymous(FAR struct task_group_s *group,
FAR struct mm_map_entry_s *entry,
FAR void *start,
size_t length)
{
int ret;
/* De-allocate memory.
* NB: This is incomplete anounymous mapping implementation
* see file_mmap_ below
*/
if (start == entry->vaddr && length == entry->length)
{
/* entry->priv marks allocation from kernel heap */
if (entry->priv.i)
{
kmm_free(start);
}
else
{
kumm_free(start);
}
ret = mm_map_remove(group, &entry);
}
else
{
ret = -EINVAL;
ferr("ERROR: Unknown map type\n");
}
return ret;
}
/****************************************************************************
* Name: file_mmap_
****************************************************************************/
@ -164,25 +125,7 @@ static int file_mmap_(FAR struct file *filep, FAR void *start,
if ((flags & MAP_ANONYMOUS) != 0)
{
/* REVISIT: Should reside outside of the heap. That is really the
* only purpose of MAP_ANONYMOUS: To get non-heap memory. In KERNEL
* build, this could be accomplished using pgalloc(), provided that
* you had logic in place to assign a virtual address to the mapping.
*/
*mapped = kernel ? kmm_zalloc(length) : kumm_zalloc(length);
if (*mapped == NULL)
{
ferr("ERROR: kumm_alloc() failed, enable DEBUG_MM for info!\n");
return -ENOMEM;
}
entry.vaddr = *mapped;
entry.munmap = unmap_anonymous;
entry.priv.i = kernel;
mm_map_add(&entry);
return OK;
return map_anonymous(&entry, kernel);
}
if ((flags & MAP_PRIVATE) != 0)