Newlib on XWOS

Multithreading

Mon, 01 Jan 0001 00:00:00 +0000

Build Configuration

When building newlib, the configuration --enable-newlib-multithread needs to be added to enable multithreading support. It is enabled by default.

_reent Structure

The header file reent.h in Newlib defines the structure struct _reent to support multithreading:

By default, Newlib defines a global structure variable impure_data, defined in newlib/libc/reent/impure.c, and represented by the macro _REENT;
struct _reent defines some C standard variables, such as errno, stdin, stdout, stderr, etc.;
To support multiple threads accessing their own errno, stdin, stdout, stderr, etc., a member of type struct _reent needs to be added to the thread object structure;
Due to the large size of struct _reent, XWOS implements struct _reent itself;
In addition to providing functions from the C standard, Newlib also defines versions of functions with the _r suffix, such as _read_r(), which have an additional struct _reent * parameter to distinguish between different threads.

Dynamic Memory Management

Mon, 01 Jan 0001 00:00:00 +0000

Description

XWOS does not use the dynamic memory management algorithm provided by Newlib. It uses a memory pool algorithm:

Porting Method

Rewrite Newlib’s functions:

void * _malloc_r(struct _reent * r, size_t n);
void * _realloc_r(struct _reent * r, void * p, size_t n);
void * _calloc_r(struct _reent * r, size_t elem_nr, size_t elem_sz);
void * _memalign_r(struct _reent * r, size_t alignment, size_t n);
void * _valloc_r(struct _reent * r, size_t n);
void * _pvalloc_r(struct _reent * r, size_t n);
void _free_r(struct _reent * r, void * p);

Source path: xwmd/libc/newlibac/mem.c
Functions not yet implemented:
- mallopt
- malloc_usable_size
- malloc_stats
- mallinfo

errno

Mon, 01 Jan 0001 00:00:00 +0000

Description

In Newlib, the errno in the standard header file <errno.h> is a macro:

/* <errno.h> */

#define errno (*__errno())
extern int *__errno (void);

int * __errno()
{
  return &_REENT->_errno;
}

Newlib’s low-level code handles errno in a very peculiar way, undefining errno and then redefining it as a variable, requiring libgloss to provide the variable definition:

/* <newlib/libc/reent/readr.c> */

#undef errno
extern int errno;

_ssize_t
_read_r (struct _reent *ptr,
     int fd,
     void *buf,
     size_t cnt)
{
  _ssize_t ret;

  errno = 0;
  if ((ret = (_ssize_t)_read (fd, buf, cnt)) == -1 && errno != 0)
    ptr->_errno = errno;
  return ret;
}

/* <libgloss/libnosys/read.c> */

#undef errno
extern int errno;

int
_read (int   file,
        char *ptr,
        int   len)
{
  errno = ENOSYS;
  return -1;
}

libgloss provides platform-related startup code, I/O support, system functions, etc., where libnosys is a stub implementation;

Porting Method

XWOS defines an __errno variable in each thread object structure and re-implements the int * __errno(void) function, returning the address of the current thread object’s __errno:

int * __errno(void)
{
        xwos_thd_d thdd = xwos_cthd_self();
        return &thdd.thd->osthd.libc.error_number;
}

When using the errno macro from <errno.h>, the thread’s own __errno can be obtained, no longer depending on libgloss.

Thread Local Storage

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Thread Local Storage (TLS) refers to variables that are private to a thread.

The C11 standard began supporting thread local storage, introducing the _Thread_local keyword. The C2X standard introduces the thread_local keyword. The gcc and clang compilers also introduce the __thread keyword.

When global variables are defined using the above keywords, each thread gets a copy of this global variable and accesses its own copy.

TLS Models

There are four TLS models in gcc and clang’s implementation: