Sinipelto
/
banan-os
forked from Bananymous/banan-os
1
0
Fork 0
Code Pull Requests Activity

LibC: Cleanup pthread code and add some pthread_attr functions 

errno, pthread cleanup and pthread id are now stored in uthread. This
allows using these without TLS
This commit is contained in:
Bananymous 2025-05-31 23:34:26 +03:00
parent 423386a052
commit c957f1ddca
17 changed files with 368 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
kernel/kernel/Process.cpp
View File

@ -350,6 +350,9 @@ namespace Kernel
.self = reinterpret_cast<struct uthread*>(region->vaddr() + master_size),
.master_tls_addr = reinterpret_cast<void*>(master_addr),
.master_tls_size = master_size,
.cleanup_stack = nullptr,
.id = -1,
.errno_ = 0,
};
const uintptr_t dtv[2] { 1, region->vaddr() };
@ -2468,11 +2471,7 @@ namespace Kernel
if (attr)
{
TRY(validate_pointer_access(attr, sizeof(*attr), false));
if (*attr)
{
dwarnln("pthread attr not supported");
return BAN::Error::from_errno(ENOTSUP);
}
dwarnln("TODO: ignoring thread attr");
}
LockGuard _(m_process_lock);

9
userspace/libraries/LibC/errno.cpp
View File

@ -1,12 +1,9 @@
#include <errno.h>
#include <pthread.h>
#if __disable_thread_local_storage
static int s_errno = 0;
#else
static thread_local int s_errno = 0;
#endif
extern uthread* _get_uthread();
int* __errno_location()
{
return &s_errno;
return &_get_uthread()->errno_;
}

3
userspace/libraries/LibC/include/aio.h
View File

@ -12,11 +12,12 @@ __BEGIN_DECLS
#include <signal.h>
#define __need_off_t
#define __need_pthread_attr_t
#define __need_size_t
#define __need_ssize_t
#include <sys/types.h>
#include <bits/types/pthread_attr_t.h>
struct aiocb
{
int aio_fildes; /* File descriptor. */

44
userspace/libraries/LibC/include/bits/pthread_types.h
View File

@ -1,44 +0,0 @@
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_types.h.html
#include <sys/cdefs.h>
__BEGIN_DECLS
#if !defined(__pthread_attr_t_defined) && (defined(__need_all_types) || defined(__need_pthread_attr_t) || defined(__need_pthread_types))
#define __pthread_attr_t_defined 1
typedef int pthread_attr_t;
#endif
#undef __need_pthread_attr_t
#if !defined(__pthread_t_defined) && (defined(__need_all_types) || defined(__need_pthread_t) || defined(__need_pthread_types))
#define __pthread_t_defined 1
typedef pid_t pthread_t;
#endif
#undef __need_pthread_t
#if !defined(__pthread_types_defined) && (defined(__need_all_types) || defined(__need_pthread_types))
#define __pthread_types_defined 1
typedef int pthread_once_t;
typedef unsigned pthread_key_t;
typedef pthread_t pthread_spinlock_t;
typedef struct { int type; int shared; } pthread_mutexattr_t;
typedef struct { pthread_mutexattr_t attr; pthread_t locker; unsigned lock_depth; } pthread_mutex_t;
typedef struct { int shared; } pthread_barrierattr_t;
typedef struct { pthread_barrierattr_t attr; unsigned target; unsigned waiting; } pthread_barrier_t;
typedef struct { int clock; int shared; } pthread_condattr_t;
struct _pthread_cond_block { struct _pthread_cond_block* next; int signaled; };
typedef struct { pthread_condattr_t attr; pthread_spinlock_t lock; struct _pthread_cond_block* block_list; } pthread_cond_t;
typedef struct { int shared; } pthread_rwlockattr_t;
typedef struct { pthread_rwlockattr_t attr; unsigned lockers; unsigned writers; } pthread_rwlock_t;
#endif
#undef __need_pthread_types
__END_DECLS

4
userspace/libraries/LibC/include/bits/types/locale_t.h
View File

@ -1,5 +1,5 @@
#ifndef _BITS_LOCALE_T_H
#define _BITS_LOCALE_T_H 1
#ifndef _BITS_TYPES_LOCALE_T_H
#define _BITS_TYPES_LOCALE_T_H 1
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/locale.h.html

25
userspace/libraries/LibC/include/bits/types/pthread_attr_t.h Normal file
View File

@ -0,0 +1,25 @@
#ifndef _BITS_TYPES_PTHREAD_ATTR_T_H
#define _BITS_TYPES_PTHREAD_ATTR_T_H 1
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html
#include <sys/cdefs.h>
__BEGIN_DECLS
#include <bits/types/sched_param.h>
typedef struct
{
int inheritsched;
struct sched_param schedparam;
int schedpolicy;
int detachstate;
int scope;
size_t stacksize;
size_t guardsize;
} pthread_attr_t;
__END_DECLS
#endif

17
userspace/libraries/LibC/include/bits/types/pthread_t.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef _BITS_TYPES_PTHREAD_T_H
#define _BITS_TYPES_PTHREAD_T_H 1
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html
#include <sys/cdefs.h>
__BEGIN_DECLS
#define __need_pid_t
#include <sys/types.h>
typedef pid_t pthread_t;
__END_DECLS
#endif

72
userspace/libraries/LibC/include/bits/types/pthread_types.h Normal file
View File

@ -0,0 +1,72 @@
#ifndef _BITS_TYPES_PTHREAD_TYPES_H
#define _BITS_TYPES_PTHREAD_TYPES_H 1
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/pthread.h.html
#include <sys/cdefs.h>
__BEGIN_DECLS
#include <bits/types/pthread_attr_t.h>
#include <bits/types/pthread_t.h>
typedef int pthread_once_t;
typedef unsigned pthread_key_t;
typedef pthread_t pthread_spinlock_t;
typedef struct
{
int type;
int shared;
} pthread_mutexattr_t;
typedef struct
{
pthread_mutexattr_t attr;
pthread_t locker;
unsigned lock_depth;
} pthread_mutex_t;
typedef struct
{
int shared;
} pthread_barrierattr_t;
typedef struct
{
pthread_barrierattr_t attr;
unsigned target;
unsigned waiting;
} pthread_barrier_t;
typedef struct
{
int clock;
int shared;
} pthread_condattr_t;
struct _pthread_cond_block
{
struct _pthread_cond_block* next;
int signaled;
};
typedef struct
{
pthread_condattr_t attr;
pthread_spinlock_t lock;
struct _pthread_cond_block* block_list;
} pthread_cond_t;
typedef struct
{
int shared;
} pthread_rwlockattr_t;
typedef struct
{
pthread_rwlockattr_t attr;
unsigned lockers;
unsigned writers;
} pthread_rwlock_t;
__END_DECLS
#endif

23
userspace/libraries/LibC/include/bits/types/sched_param.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef _BITS_TYPES_SCHED_PARAM_H
#define _BITS_TYPES_SCHED_PARAM_H 1
// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sched.h.html
#include <sys/cdefs.h>
__BEGIN_DECLS
#include <time.h>
struct sched_param
{
int sched_priority; /* Process or thread execution scheduling priority. */
int sched_ss_low_priority; /* Low scheduling priority for sporadic server. */
struct timespec sched_ss_repl_period; /* Replenishment period for sporadic server. */
struct timespec sched_ss_init_budget; /* Initial budget for sporadic server. */
int sched_ss_max_repl; /* Maximum pending replenishments for sporadic server. */
};
__END_DECLS
#endif

4
userspace/libraries/LibC/include/bits/types/timeval.h
View File

@ -1,5 +1,5 @@
#ifndef _BITS_TIMEVAL_H
#define _BITS_TIMEVAL_H 1
#ifndef _BITS_TYPES_TIMEVAL_H
#define _BITS_TYPES_TIMEVAL_H 1
#include <sys/cdefs.h>

3
userspace/libraries/LibC/include/mqueue.h
View File

@ -10,11 +10,12 @@ __BEGIN_DECLS
#include <time.h>
#include <signal.h>
#define __need_pthread_attr_t
#define __need_size_t
#define __need_ssize_t
#include <sys/types.h>
#include <bits/types/pthread_attr_t.h>
typedef int mqd_t;
struct mq_attr

42
userspace/libraries/LibC/include/pthread.h
View File

@ -13,29 +13,45 @@ __BEGIN_DECLS
#define __need_size_t
#define __need_clockid_t
#define __need_pthread_types
#include <sys/types.h>
#include <bits/types/pthread_types.h>
struct _pthread_cleanup_t
{
void (*routine)(void*);
void* arg;
struct _pthread_cleanup_t* next;
};
struct uthread
{
struct uthread* self;
void* master_tls_addr;
size_t master_tls_size;
struct _pthread_cleanup_t* cleanup_stack;
pthread_t id;
int errno_;
uintptr_t dtv[];
};
#define PTHREAD_CANCEL_ASYNCHRONOUS 2
#define PTHREAD_CANCEL_ENABLE 3
#define PTHREAD_CANCEL_DEFERRED 4
#define PTHREAD_CANCEL_DISABLE 5
#define PTHREAD_CANCELED 6
#define PTHREAD_EXPLICIT_SCHED 9
#define PTHREAD_INHERIT_SCHED 10
#define PTHREAD_PRIO_INHERIT 18
#define PTHREAD_PRIO_NONE 19
#define PTHREAD_PRIO_PROTECT 20
#define PTHREAD_SCOPE_PROCESS 23
#define PTHREAD_SCOPE_SYSTEM 24
#define PTHREAD_CANCELED 1
#define PTHREAD_CANCEL_ASYNCHRONOUS 1
#define PTHREAD_CANCEL_DEFERRED 0
#define PTHREAD_CANCEL_DISABLE 0
#define PTHREAD_CANCEL_ENABLE 1
#define PTHREAD_PRIO_INHERIT 1
#define PTHREAD_PRIO_NONE 0
#define PTHREAD_PRIO_PROTECT 2
#define PTHREAD_EXPLICIT_SCHED 1
#define PTHREAD_INHERIT_SCHED 0
#define PTHREAD_SCOPE_PROCESS 1
#define PTHREAD_SCOPE_SYSTEM 0
#define PTHREAD_CREATE_DETACHED 1
#define PTHREAD_CREATE_JOINABLE 0

9
userspace/libraries/LibC/include/sched.h
View File

@ -12,14 +12,7 @@ __BEGIN_DECLS
#define __need_pid_t
#include <sys/types.h>
struct sched_param
{
int sched_priority; /* Process or thread execution scheduling priority. */
int sched_ss_low_priority; /* Low scheduling priority for sporadic server. */
struct timespec sched_ss_repl_period; /* Replenishment period for sporadic server. */
struct timespec sched_ss_init_budget; /* Initial budget for sporadic server. */
int sched_ss_max_repl; /* Maximum pending replenishments for sporadic server. */
};
#include <bits/types/sched_param.h>
#define SCHED_FIFO 1
#define SCHED_RR 2

5
userspace/libraries/LibC/include/signal.h
View File

@ -14,13 +14,14 @@ __BEGIN_DECLS
#define SIG_HOLD ((void (*)(int))2)
#define SIG_IGN ((void (*)(int))3)
#define __need_pthread_t
#define __need_size_t
#define __need_uid_t
#define __need_pid_t
#define __need_pthread_attr_t
#include <sys/types.h>
#include <bits/types/pthread_attr_t.h>
#include <bits/types/pthread_t.h>
typedef int sig_atomic_t;
typedef unsigned long long sigset_t;

9
userspace/libraries/LibC/include/sys/types.h
View File

@ -21,9 +21,6 @@ __BEGIN_DECLS
&& !defined(__need_nlink_t) \
&& !defined(__need_off_t) \
&& !defined(__need_pid_t) \
&& !defined(__need_pthread_attr_t) \
&& !defined(__need_pthread_t) \
&& !defined(__need_pthread_types) \
&& !defined(__need_size_t) \
&& !defined(__need_ssize_t) \
&& !defined(__need_suseconds_t) \
@ -122,18 +119,12 @@ __BEGIN_DECLS
#endif
#undef __need_off_t
#ifdef __need_pthread_t
#define __need_pid_t
#endif
#if !defined(__pid_t_defined) && (defined(__need_all_types) || defined(__need_pid_t))
#define __pid_t_defined 1
typedef int pid_t;
#endif
#undef __need_pid_t
#include <bits/pthread_types.h>
#if !defined(__size_t_defined) && (defined(__need_all_types) || defined(__need_size_t))
#define __size_t_defined 1
#define __need_size_t

223
userspace/libraries/LibC/pthread.cpp
View File

@ -4,6 +4,7 @@
#include <BAN/PlacementNew.h>
#include <kernel/Arch.h>
#include <kernel/Thread.h>
#include <errno.h>
#include <pthread.h>
@ -46,13 +47,16 @@ asm(
extern "C" void _pthread_trampoline_cpp(void* arg)
{
auto info = *reinterpret_cast<pthread_trampoline_info_t*>(arg);
info.uthread->id = syscall(SYS_PTHREAD_SELF);
info.uthread->errno_ = 0;
info.uthread->cleanup_stack = nullptr;
syscall(SYS_SET_TLS, info.uthread);
free(arg);
pthread_exit(info.start_routine(info.arg));
ASSERT_NOT_REACHED();
}
static uthread* get_uthread()
uthread* _get_uthread()
{
uthread* result;
#if ARCH(x86_64)
@ -75,22 +79,13 @@ static void free_uthread(uthread* uthread)
munmap(tls_addr, tls_size);
}
#if not __disable_thread_local_storage
struct pthread_cleanup_t
{
void (*routine)(void*);
void* arg;
pthread_cleanup_t* next;
};
static thread_local pthread_cleanup_t* s_cleanup_stack = nullptr;
void pthread_cleanup_pop(int execute)
{
ASSERT(s_cleanup_stack);
uthread* uthread = _get_uthread();
ASSERT(uthread->cleanup_stack);
auto* cleanup = s_cleanup_stack;
s_cleanup_stack = cleanup->next;
auto* cleanup = uthread->cleanup_stack;
uthread->cleanup_stack = cleanup->next;
if (execute)
cleanup->routine(cleanup->arg);
@ -100,16 +95,17 @@ void pthread_cleanup_pop(int execute)
void pthread_cleanup_push(void (*routine)(void*), void* arg)
{
auto* cleanup = static_cast<pthread_cleanup_t*>(malloc(sizeof(pthread_cleanup_t)));
auto* cleanup = static_cast<_pthread_cleanup_t*>(malloc(sizeof(_pthread_cleanup_t)));
ASSERT(cleanup);
uthread* uthread = _get_uthread();
cleanup->routine = routine;
cleanup->arg = arg;
cleanup->next = s_cleanup_stack;
cleanup->next = uthread->cleanup_stack;
s_cleanup_stack = cleanup;
uthread->cleanup_stack = cleanup;
}
#endif
#if not __disable_thread_local_storage
static thread_local struct {
@ -175,38 +171,156 @@ int pthread_attr_destroy(pthread_attr_t* attr)
int pthread_attr_init(pthread_attr_t* attr)
{
*attr = 0;
return 0;
}
int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stacksize)
{
(void)attr;
(void)stacksize;
dwarnln("TODO: ignoring pthread_attr_setstacksize");
*attr = {
.inheritsched = PTHREAD_INHERIT_SCHED,
.schedparam = {},
.schedpolicy = SCHED_RR,
.detachstate = PTHREAD_CREATE_JOINABLE,
.scope = PTHREAD_SCOPE_SYSTEM,
.stacksize = Kernel::Thread::userspace_stack_size,
.guardsize = static_cast<size_t>(getpagesize()),
};
return 0;
}
int pthread_attr_getdetachstate(const pthread_attr_t* attr, int* detachstate)
{
(void)attr;
*detachstate = PTHREAD_CREATE_JOINABLE;
*detachstate = attr->detachstate;
return 0;
}
int pthread_attr_setdetachstate(pthread_attr_t* attr, int detachstate)
{
(void)attr;
switch (detachstate)
{
case PTHREAD_CREATE_DETACHED:
dwarnln("TODO: pthread_attr_setdetachstate");
return ENOTSUP;
case PTHREAD_CREATE_JOINABLE:
attr->detachstate = detachstate;
return 0;
default:
}
return EINVAL;
}
int pthread_attr_getguardsize(const pthread_attr_t* __restrict attr, size_t* __restrict guardsize)
{
*guardsize = attr->guardsize;
return 0;
}
int pthread_attr_setguardsize(pthread_attr_t* attr, size_t guardsize)
{
attr->guardsize = guardsize;
return 0;
}
int pthread_attr_getinheritsched(const pthread_attr_t* __restrict attr, int* __restrict inheritsched)
{
*inheritsched = attr->inheritsched;
return 0;
}
int pthread_attr_setinheritsched(pthread_attr_t* attr, int inheritsched)
{
switch (inheritsched)
{
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
}
return EINVAL;
}
int pthread_attr_getschedparam(const pthread_attr_t* __restrict attr, struct sched_param* __restrict param)
{
*param = attr->schedparam;
return 0;
}
int pthread_attr_setschedparam(pthread_attr_t* __restrict attr, const struct sched_param* __restrict param)
{
attr->schedparam = *param;
return 0;
}
int pthread_attr_getschedpolicy(const pthread_attr_t* __restrict attr, int* __restrict policy)
{
*policy = attr->schedpolicy;
return 0;
}
int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy)
{
switch (policy)
{
case SCHED_FIFO:
case SCHED_SPORADIC:
case SCHED_OTHER:
return ENOTSUP;
case SCHED_RR:
attr->schedpolicy = policy;
return 0;
}
return EINVAL;
}
int pthread_attr_getscope(const pthread_attr_t* __restrict attr, int* __restrict contentionscope)
{
*contentionscope = attr->scope;
return 0;
}
int pthread_attr_setscope(pthread_attr_t* attr, int contentionscope)
{
switch (contentionscope)
{
case PTHREAD_SCOPE_PROCESS:
return ENOTSUP;
case PTHREAD_SCOPE_SYSTEM:
attr->scope = contentionscope;
return 0;
}
return EINVAL;
}
int pthread_attr_getstack(const pthread_attr_t* __restrict attr, void** __restrict stackaddr, size_t* __restrict stacksize)
{
(void)attr;
(void)stackaddr;
(void)stacksize;
dwarnln("TODO: pthread_attr_getstack");
return ENOTSUP;
}
int pthread_attr_setstack(pthread_attr_t* attr, void* stackaddr, size_t stacksize)
{
(void)attr;
(void)stackaddr;
(void)stacksize;
dwarnln("TODO: pthread_attr_setstack");
return ENOTSUP;
}
int pthread_attr_getstacksize(const pthread_attr_t* __restrict attr, size_t* __restrict stacksize)
{
*stacksize = attr->stacksize;
return 0;
}
int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stacksize)
{
attr->stacksize = stacksize;
return 0;
}
int pthread_setcancelstate(int state, int* oldstate)
{
(void)state;
(void)oldstate;
dwarnln("TODO: pthread_setcancelstate");
return 0;
}
int pthread_create(pthread_t* __restrict thread_id, const pthread_attr_t* __restrict attr, void* (*start_routine)(void*), void* __restrict arg)
@ -223,14 +337,20 @@ int pthread_create(pthread_t* __restrict thread_id, const pthread_attr_t* __rest
long syscall_ret = 0;
if (uthread* self = get_uthread(); self->master_tls_addr == nullptr)
if (uthread* self = _get_uthread(); self->master_tls_addr == nullptr)
{
uthread* uthread = static_cast<struct uthread*>(malloc(sizeof(struct uthread) + sizeof(uintptr_t)));
if (uthread == nullptr)
goto pthread_create_error;
uthread->self = uthread;
uthread->master_tls_addr = nullptr;
uthread->master_tls_size = 0;
*uthread = {
.self = uthread,
.master_tls_addr = nullptr,
.master_tls_size = 0,
.cleanup_stack = nullptr,
.id = -1,
.errno_ = 0,
};
uthread->dtv[0] = 0;
info->uthread = uthread;
@ -249,9 +369,14 @@ int pthread_create(pthread_t* __restrict thread_id, const pthread_attr_t* __rest
memcpy(tls_addr, self->master_tls_addr, self->master_tls_size);
uthread* uthread = reinterpret_cast<struct uthread*>(tls_addr + self->master_tls_size);
uthread->self = uthread;
uthread->master_tls_addr = self->master_tls_addr;
uthread->master_tls_size = self->master_tls_size;
*uthread = {
.self = uthread,
.master_tls_addr = self->master_tls_addr,
.master_tls_size = self->master_tls_size,
.cleanup_stack = nullptr,
.id = -1,
.errno_ = 0,
};
const uintptr_t self_addr = reinterpret_cast<uintptr_t>(self);
const uintptr_t uthread_addr = reinterpret_cast<uintptr_t>(uthread);
@ -288,9 +413,11 @@ int pthread_detach(pthread_t thread)
void pthread_exit(void* value_ptr)
{
#if not __disable_thread_local_storage
while (s_cleanup_stack)
uthread* uthread = _get_uthread();
while (uthread->cleanup_stack)
pthread_cleanup_pop(1);
#if not __disable_thread_local_storage
for (size_t iteration = 0; iteration < PTHREAD_DESTRUCTOR_ITERATIONS; iteration++)
{
bool called = false;
@ -309,7 +436,8 @@ void pthread_exit(void* value_ptr)
break;
}
#endif
free_uthread(get_uthread());
free_uthread(uthread);
syscall(SYS_PTHREAD_EXIT, value_ptr);
ASSERT_NOT_REACHED();
}
@ -326,14 +454,7 @@ int pthread_join(pthread_t thread, void** value_ptr)
pthread_t pthread_self(void)
{
#if __disable_thread_local_storage
return syscall(SYS_PTHREAD_SELF);
#else
static thread_local pthread_t s_pthread_self { -1 };
if (s_pthread_self == -1) [[unlikely]]
s_pthread_self = syscall(SYS_PTHREAD_SELF);
return s_pthread_self;
#endif
return _get_uthread()->id;
}
int pthread_once(pthread_once_t* once_control, void (*init_routine)(void))
@ -732,7 +853,7 @@ int pthread_condattr_getpshared(const pthread_condattr_t* __restrict attr, int*
return 0;
}
int pthread_condattr_setpshared(pthread_barrierattr_t* attr, int pshared)
int pthread_condattr_setpshared(pthread_condattr_t* attr, int pshared)
{
switch (pshared)
{
@ -925,7 +1046,7 @@ struct tls_index
extern "C" void* __tls_get_addr(tls_index* ti)
{
return reinterpret_cast<void*>(get_uthread()->dtv[ti->ti_module] + ti->ti_offset);
return reinterpret_cast<void*>(_get_uthread()->dtv[ti->ti_module] + ti->ti_offset);
}
#if ARCH(i686)

11
userspace/libraries/LibC/unistd.cpp
View File

@ -34,7 +34,13 @@ extern "C" void _init_libc(char** environ, init_funcs_t init_funcs, init_funcs_t
if (::environ == nullptr)
::environ = environ;
if (syscall(SYS_GET_TLS) == 0)
if (uthread* self = reinterpret_cast<uthread*>(syscall(SYS_GET_TLS)))
{
self->cleanup_stack = nullptr;
self->id = syscall(SYS_PTHREAD_SELF);
self->errno_ = 0;
}
else
{
alignas(uthread) static uint8_t storage[sizeof(uthread) + sizeof(uintptr_t)];
@ -43,6 +49,9 @@ extern "C" void _init_libc(char** environ, init_funcs_t init_funcs, init_funcs_t
.self = &uthread,
.master_tls_addr = nullptr,
.master_tls_size = 0,
.cleanup_stack = nullptr,
.id = static_cast<pthread_t>(syscall(SYS_PTHREAD_SELF)),
.errno_ = 0,
};
uthread.dtv[0] = 0;