malloc.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016 Liviu Ionescu.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
 
#if defined(__ARM_EABI__) || defined(__DOXYGEN__)
 
// ----------------------------------------------------------------------------
 
#include <cmsis-plus/rtos/os.h>
#include <cmsis-plus/estd/memory_resource>
 
#include <malloc.h>
 
// ----------------------------------------------------------------------------
 
using namespace os;
 
// ----------------------------------------------------------------------------
 
// These library functions were modified to use the application
// memory resource and to be thread safe.
void*
malloc (size_t bytes)
{
  assert(!rtos::interrupts::in_handler_mode ());
 
  void* mem;
    {
      // ----- Begin of critical section --------------------------------------
      rtos::scheduler::critical_section scs;
 
      errno = 0;
      mem = estd::pmr::get_default_resource ()->allocate (bytes);
      if (mem == nullptr)
        {
          errno = ENOMEM;
        }
 
#if defined(OS_TRACE_LIBC_MALLOC)
      trace::printf ("::%s(%d)=%p\n", __func__, bytes, mem);
#endif
      // ----- End of critical section ----------------------------------------
    }
 
  return mem;
}
 
void*
calloc (size_t nelem, size_t elbytes)
{
  assert(!rtos::interrupts::in_handler_mode ());
 
  errno = 0;
  if (nelem == 0 || elbytes == 0)
    {
      return nullptr;
    }
 
  void* mem;
    {
      // ----- Begin of critical section --------------------------------------
      rtos::scheduler::critical_section scs;
 
      mem = estd::pmr::get_default_resource ()->allocate (nelem * elbytes);
 
#if defined(OS_TRACE_LIBC_MALLOC)
      trace::printf ("::%s(%u,%u)=%p\n", __func__, nelem, elbytes, mem);
#endif
      // ----- End of critical section ----------------------------------------
    }
 
  if (mem != nullptr)
    {
      memset (mem, 0, nelem * elbytes);
    }
  else
    {
      errno = ENOMEM;
    }
 
  return mem;
}
 
void*
realloc (void* ptr, size_t bytes)
{
  assert(!rtos::interrupts::in_handler_mode ());
 
  void* mem;
 
    {
      // ----- Begin of critical section --------------------------------------
      rtos::scheduler::critical_section scs;
 
      errno = 0;
      if (ptr == nullptr)
        {
          mem = estd::pmr::get_default_resource ()->allocate (bytes);
#if defined(OS_TRACE_LIBC_MALLOC)
          trace::printf ("::%s(%p,%u)=%p\n", __func__, ptr, bytes, mem);
#endif
          if (mem == nullptr)
            {
              errno = ENOMEM;
            }
          return mem;
        }
 
      if (bytes == 0)
        {
          estd::pmr::get_default_resource ()->deallocate (ptr, 0);
#if defined(OS_TRACE_LIBC_MALLOC)
          trace::printf ("::%s(%p,%u)=0\n", __func__, ptr, bytes);
#endif
          return nullptr;
        }
 
#if 0
      /* TODO: There is chance to shrink the chunk if newly requested
       * size is much small */
      if (nano_malloc_usable_size (RCALL ptr) >= bytes)
      return ptr;
#endif
 
      mem = estd::pmr::get_default_resource ()->allocate (bytes);
      if (mem != nullptr)
        {
          memcpy (mem, ptr, bytes);
          estd::pmr::get_default_resource ()->deallocate (ptr, 0);
        }
      else
        {
          errno = ENOMEM;
        }
 
#if defined(OS_TRACE_LIBC_MALLOC)
      trace::printf ("::%s(%p,%u)=%p", __func__, ptr, bytes, mem);
#endif
      // ----- End of critical section ----------------------------------------
    }
 
  return mem;
}
 
void
free (void* ptr)
{
  assert(!rtos::interrupts::in_handler_mode ());
 
  if (ptr == nullptr)
    {
      return;
    }
 
  // ----- Begin of critical section ------------------------------------------
  rtos::scheduler::critical_section scs;
 
#if defined(OS_TRACE_LIBC_MALLOC)
  trace::printf ("::%s(%p)\n", __func__, ptr);
#endif
 
  // Size unknown, pass 0.
  estd::pmr::get_default_resource ()->deallocate (ptr, 0);
  // ----- End of critical section --------------------------------------------
}
 
// ----------------------------------------------------------------------------
// Redirect impure functions to the implementation, to avoid including
// weird newlib functions.
void*
_malloc_r (struct _reent* impure __attribute__((unused)), size_t size)
{
  return malloc (size);
}
 
void*
_calloc_r (struct _reent* impure __attribute__((unused)), size_t n, size_t elem)
{
  return calloc (n, elem);
}
 
void
_free_r (struct _reent* impure __attribute__((unused)), void* ptr)
{
  free (ptr);
}
 
void*
_realloc_r (struct _reent* impure __attribute__((unused)), void* ptr,
            size_t size)
{
  return realloc (ptr, size);
}
 
// ----------------------------------------------------------------------------
// Not really implemented, but present here to avoid including
// weird newlib functions.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
 
struct mallinfo
_mallinfo_r (struct _reent* impure __attribute__((unused)))
{
  abort ();
}
 
#pragma GCC diagnostic pop
 
void
_malloc_stats_r (struct _reent* impure __attribute__((unused)))
{
  abort ();
}
 
size_t
_malloc_usable_size_r (struct _reent* reent __attribute__((unused)),
                       void* ptr __attribute__((unused)))
{
  abort ();
}
 
int
_mallopt_r (struct _reent* impure __attribute__((unused)),
            int parameter_number __attribute__((unused)),
            int parameter_value __attribute__((unused)))
{
  abort ();
}
 
void*
_memalign_r (struct _reent* impure __attribute__((unused)),
             size_t align __attribute__((unused)),
             size_t s __attribute__((unused)))
{
  abort ();
}
 
void*
_pvalloc_r (struct _reent* impure __attribute__((unused)),
            size_t s __attribute__((unused)))
{
  abort ();
}
 
void*
_valloc_r (struct _reent* impure __attribute__((unused)),
           size_t s __attribute__((unused)))
{
  abort ();
}
 
// ----------------------------------------------------------------------------
 
#endif /* defined(__ARM_EABI__) */