Some renaming for consistency, new check function added, documentation fixes.
git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@15344 27425a3e-05d8-49a3-a47f-9c15f0e5edd8
This commit is contained in:
Giovanni Di Sirio
parent
44ccf3952d
commit
b48f8ebdaa
|
|
@ -83,15 +83,15 @@ extern "C" {
|
|||
bool chMemIsStringWithinX(const memory_area_t *map,
|
||||
const char *s,
|
||||
size_t n);
|
||||
bool chMemIsAreaContainedX(const memory_area_t areas[],
|
||||
const void *p,
|
||||
size_t size);
|
||||
bool chMemIsAreaWritableX(void *p,
|
||||
size_t size,
|
||||
unsigned align);
|
||||
bool chMemIsAreaReadableX(const void *p,
|
||||
size_t size,
|
||||
unsigned align);
|
||||
bool chMemIsSpaceContainedX(const memory_area_t areas[],
|
||||
const void *p,
|
||||
size_t size);
|
||||
bool chMemIsSpaceWritableX(void *p,
|
||||
size_t size,
|
||||
unsigned align);
|
||||
bool chMemIsSpaceReadableX(const void *p,
|
||||
size_t size,
|
||||
unsigned align);
|
||||
bool chMemIsAddressExecutableX(const void *p);
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
|
|
@ -103,23 +103,22 @@ extern "C" {
|
|||
/*===========================================================================*/
|
||||
|
||||
/**
|
||||
* @brief Memory area check.
|
||||
* @details Checks if specified area belongs to the specified memory area.
|
||||
* @brief Memory space inclusion check.
|
||||
* @details Checks if specified space belongs to the specified memory area.
|
||||
*
|
||||
* @param[in] map pointer to a @p memory_area_t structure
|
||||
* @param[in] p pointer to the area to be checked
|
||||
* @param[in] size size of the area to be checked, zero is considered
|
||||
* the whole address space
|
||||
* @param[in] p pointer to the memory space to be checked
|
||||
* @param[in] size size of the memory space to be checked, zero is
|
||||
* considered the whole address space
|
||||
* @return The test result.
|
||||
* @retval true if the area is entirely contained within one of the
|
||||
* specified areas.
|
||||
* @retval false if the area check failed.
|
||||
* @retval true if the memory space is entirely contained.
|
||||
* @retval false if the memory space is not entirely contained.
|
||||
*
|
||||
* @xclass
|
||||
*/
|
||||
static inline bool chMemIsAreaWithinX(const memory_area_t *map,
|
||||
const void *p,
|
||||
size_t size) {
|
||||
static inline bool chMemIsSpaceWithinX(const memory_area_t *map,
|
||||
const void *p,
|
||||
size_t size) {
|
||||
const uint8_t *mem_base = (const uint8_t *)map->base;
|
||||
const uint8_t *mem_end = mem_base + map->size - (size_t)1;
|
||||
const uint8_t *base = (const uint8_t *)p;
|
||||
|
|
@ -130,6 +129,33 @@ static inline bool chMemIsAreaWithinX(const memory_area_t *map,
|
|||
return (bool)((base <= end) && (base >= mem_base) && (end <= mem_end));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Memory space intersection check.
|
||||
* @details Checks if specified memory space intersects the specified memory
|
||||
* area.
|
||||
*
|
||||
* @param[in] map pointer to a @p memory_area_t structure
|
||||
* @param[in] p pointer to the memory space to be checked
|
||||
* @param[in] size size of the memory space to be checked, zero is
|
||||
* considered the whole address space
|
||||
* @return The test result.
|
||||
* @retval true if the memory space is intersecting.
|
||||
* @retval false if the memory space is not intersecting.
|
||||
*
|
||||
* @xclass
|
||||
*/
|
||||
static inline bool chMemIsSpaceIntersectingX(const memory_area_t *map,
|
||||
const void *p,
|
||||
size_t size) {
|
||||
const uint8_t *mem_base = (const uint8_t *)map->base;
|
||||
const uint8_t *mem_end = mem_base + map->size - (size_t)1;
|
||||
const uint8_t *base = (const uint8_t *)p;
|
||||
const uint8_t *end = base + size - (size_t)1;
|
||||
|
||||
return (bool)(((base >= mem_base) && (base <= mem_end)) ||
|
||||
((end >= mem_base) && (end <= mem_end)));
|
||||
}
|
||||
|
||||
#if CH_CFG_USE_MEMCHECKS == FALSE
|
||||
/* Stub implementations for when the functionality is disabled, areas are
|
||||
always reported as valid.*/
|
||||
|
|
|
|||
|
|
@ -121,31 +121,32 @@ bool chMemIsStringWithinX(const memory_area_t *map, const char *s, size_t n) {
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Memory area check.
|
||||
* @details Checks if specified area belongs to one of the specified areas.
|
||||
* @brief Memory space check.
|
||||
* @details Checks if specified memory space belongs to one of the specified
|
||||
* areas.
|
||||
*
|
||||
* @param[in] map array of valid areas terminated with an end
|
||||
* marker (base=-1)
|
||||
* @param[in] p pointer to the area to be checked
|
||||
* @param[in] size size of the area to be checked, zero is considered
|
||||
* the whole address space
|
||||
* @param[in] p pointer to the memory space to be checked
|
||||
* @param[in] size size of the memory space to be checked, zero is
|
||||
* considered the whole address space
|
||||
* @return The test result.
|
||||
* @retval true if the area is entirely contained within one of the
|
||||
* specified areas.
|
||||
* @retval false if the area check failed.
|
||||
* @retval true if the memory space is entirely contained within one
|
||||
* of the specified areas.
|
||||
* @retval false if the memory space check failed.
|
||||
*
|
||||
* @xclass
|
||||
*/
|
||||
bool chMemIsAreaContainedX(const memory_area_t areas[],
|
||||
const void *p,
|
||||
size_t size) {
|
||||
bool chMemIsSpaceContainedX(const memory_area_t areas[],
|
||||
const void *p,
|
||||
size_t size) {
|
||||
const memory_area_t *map = &areas[0];
|
||||
|
||||
chDbgCheck(p != NULL);
|
||||
|
||||
/* Scanning the array of the valid areas for a mismatch.*/
|
||||
while (map->base != (uint8_t *)-1) {
|
||||
if (chMemIsAreaWithinX(map, p, size)) {
|
||||
if (chMemIsSpaceWithinX(map, p, size)) {
|
||||
return true;
|
||||
}
|
||||
map++;
|
||||
|
|
@ -157,27 +158,27 @@ bool chMemIsAreaContainedX(const memory_area_t areas[],
|
|||
#if (CH_CFG_USE_MEMCHECKS == TRUE) || defined(__DOXYGEN__)
|
||||
|
||||
/**
|
||||
* @brief Memory writable area check.
|
||||
* @details Checks if specified pointer belongs to one of the system-defined
|
||||
* writable areas and is aligned as specified.
|
||||
* @brief Writable memory space check.
|
||||
* @details Checks if the specified memory space belongs to one of the
|
||||
* system-defined writable areas and is aligned as specified.
|
||||
* @note @p __ch_mem_writable_areas must be the name of a global
|
||||
* @p memory_area_t array terminated with an end marker (-1, 0).
|
||||
*
|
||||
* @param[in] p pointer to the area to be checked
|
||||
* @param[in] size size of the area to be checked, zero is considered
|
||||
* the whole address space
|
||||
* @param[in] p pointer to the memory space to be checked
|
||||
* @param[in] size size of the memory space to be checked, zero is
|
||||
* considered the whole address space
|
||||
* @param[in] align required pointer alignment to be checked, must be
|
||||
* a power of two
|
||||
* @return The test result.
|
||||
* @retval true if the area is entirely contained within one of the
|
||||
* system-defined writable areas.
|
||||
* @retval false if the area check failed.
|
||||
* @retval true if the memory space is entirely contained within one
|
||||
* memory space system-defined writable areas.
|
||||
* @retval false if the memory space check failed.
|
||||
*
|
||||
* @xclass
|
||||
*/
|
||||
bool chMemIsAreaWritableX(void *p,
|
||||
size_t size,
|
||||
unsigned align) {
|
||||
bool chMemIsSpaceWritableX(void *p,
|
||||
size_t size,
|
||||
unsigned align) {
|
||||
|
||||
chDbgCheck((align & (align - 1U)) == 0U);
|
||||
|
||||
|
|
@ -185,31 +186,31 @@ bool chMemIsAreaWritableX(void *p,
|
|||
return false;
|
||||
}
|
||||
|
||||
return chMemIsAreaContainedX(__ch_mem_writable_areas, p, size);
|
||||
return chMemIsSpaceContainedX(__ch_mem_writable_areas, p, size);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Memory readable area check.
|
||||
* @details Checks if specified pointer belongs to one of the system-defined
|
||||
* readable areas and is aligned as specified.
|
||||
* @brief Readable memory space check.
|
||||
* @details Checks if specified memory space belongs to one of the
|
||||
* system-defined readable areas and is aligned as specified.
|
||||
* @note @p __ch_mem_readable_areas must be the name of a global
|
||||
* @p memory_area_t array terminated with an end marker (-1, 0).
|
||||
*
|
||||
* @param[in] p pointer to the area to be checked
|
||||
* @param[in] size size of the area to be checked, zero is considered
|
||||
* the whole address space
|
||||
* @param[in] p pointer to the memory space to be checked
|
||||
* @param[in] size size of the memory space to be checked, zero is
|
||||
* considered the whole address space
|
||||
* @param[in] align required pointer alignment to be checked, must be
|
||||
* a power of two
|
||||
* @return The test result.
|
||||
* @retval true if the area is entirely contained within one of the
|
||||
* system-defined readable areas.
|
||||
* @retval false if the area check failed.
|
||||
* @retval true if the memory space is entirely contained within one
|
||||
* of the system-defined readable areas.
|
||||
* @retval false if the memory space check failed.
|
||||
*
|
||||
* @xclass
|
||||
*/
|
||||
bool chMemIsAreaReadableX(const void *p,
|
||||
size_t size,
|
||||
unsigned align) {
|
||||
bool chMemIsSpaceReadableX(const void *p,
|
||||
size_t size,
|
||||
unsigned align) {
|
||||
|
||||
chDbgCheck((align & (align - 1U)) == 0U);
|
||||
|
||||
|
|
@ -217,7 +218,7 @@ bool chMemIsAreaReadableX(const void *p,
|
|||
return false;
|
||||
}
|
||||
|
||||
return chMemIsAreaContainedX(__ch_mem_readable_areas, p, size);
|
||||
return chMemIsSpaceContainedX(__ch_mem_readable_areas, p, size);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -243,7 +244,7 @@ bool chMemIsAddressExecutableX(const void *p) {
|
|||
return false;
|
||||
}
|
||||
|
||||
return chMemIsAreaContainedX(__ch_mem_executable_areas, p, 1);
|
||||
return chMemIsSpaceContainedX(__ch_mem_executable_areas, p, 1);
|
||||
}
|
||||
|
||||
#endif /* CH_CFG_USE_MEMCHECKS == TRUE */
|
||||
|
|
|
|||
|
|
@ -447,9 +447,9 @@ bool chHeapIntegrityCheck(memory_heap_t *heapp) {
|
|||
}
|
||||
|
||||
/* Validating the found free block.*/
|
||||
if (!chMemIsAreaWithinX(&heapp->area,
|
||||
(void *)hp,
|
||||
H_FREE_FULLSIZE(hp))) {
|
||||
if (!chMemIsSpaceWithinX(&heapp->area,
|
||||
(void *)hp,
|
||||
H_FREE_FULLSIZE(hp))) {
|
||||
result = true;
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -206,9 +206,9 @@ static msg_t allocate_section(elf_load_context_t *ctxp,
|
|||
|
||||
/* Checking if the section can fit into the destination memory area.*/
|
||||
load_address = ctxp->map->base + shp->sh_addr;
|
||||
if (!chMemIsAreaWithinX(ctxp->map,
|
||||
(const void *)load_address,
|
||||
(size_t)shp->sh_size)) {
|
||||
if (!chMemIsSpaceWithinX(ctxp->map,
|
||||
(const void *)load_address,
|
||||
(size_t)shp->sh_size)) {
|
||||
return CH_RET_ENOMEM;
|
||||
}
|
||||
|
||||
|
|
@ -290,9 +290,9 @@ static msg_t reloc_entry(elf_load_context_t *ctxp,
|
|||
relocation_address = (uint32_t)ctxp->map->base +
|
||||
lip->address +
|
||||
rp->r_offset;
|
||||
if (!chMemIsAreaWithinX(ctxp->map,
|
||||
(const void *)relocation_address,
|
||||
sizeof (uint32_t))) {
|
||||
if (!chMemIsSpaceWithinX(ctxp->map,
|
||||
(const void *)relocation_address,
|
||||
sizeof (uint32_t))) {
|
||||
return CH_RET_ENOMEM;
|
||||
}
|
||||
|
||||
|
|
@ -372,7 +372,7 @@ static msg_t load_relocate_section(elf_load_context_t *ctxp,
|
|||
|
||||
/* Checking if the section can fit into the destination memory area.*/
|
||||
load_address = ctxp->map->base + lip->address;
|
||||
if (!chMemIsAreaWithinX(ctxp->map,
|
||||
if (!chMemIsSpaceWithinX(ctxp->map,
|
||||
(const void *)load_address,
|
||||
lip->bits_size)) {
|
||||
return CH_RET_ENOMEM;
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ bool sb_is_valid_read_range(sb_class_t *sbcp, const void *start, size_t size) {
|
|||
const sb_memory_region_t *rp = &sbcp->config->regions[0];
|
||||
|
||||
do {
|
||||
if (chMemIsAreaContainedX(&rp->area, start, size)) {
|
||||
if (chMemIsSpaceWithinX(&rp->area, start, size)) {
|
||||
return true;
|
||||
}
|
||||
rp++;
|
||||
|
|
@ -74,7 +74,7 @@ bool sb_is_valid_write_range(sb_class_t *sbcp, void *start, size_t size) {
|
|||
const sb_memory_region_t *rp = &sbcp->config->regions[0];
|
||||
|
||||
do {
|
||||
if (chMemIsAreaWithinX(&rp->area, start, size)) {
|
||||
if (chMemIsSpaceWithinX(&rp->area, start, size)) {
|
||||
return rp->writeable;
|
||||
}
|
||||
rp++;
|
||||
|
|
|
|||
Loading…
Reference in New Issue