/* $OpenBSD: tib.h,v 1.10 2023/12/08 19:14:36 miod Exp $ */ /* * Copyright (c) 2011,2014 Philip Guenther <guenther@openbsd.org> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Thread Information Block (TIB) and Thread Local Storage (TLS) handling * (the TCB, Thread Control Block, is part of the TIB) */ #ifndef _TIB_H_ #define _TIB_H_ #include <sys/types.h> #include <machine/tcb.h> #include <stddef.h> /* * This header defines struct tib and at least eight macros: * TLS_VARIANT * Either 1 or 2 (Actually defined by <machine/tcb.h>) * * TCB_SET(tcb) * Set the TCB pointer for this thread to 'tcb' * * TCB_GET() * Return the TCB pointer for this thread * * TCB_TO_TIB(tcb) * Given a TCB pointer, return the matching TIB pointer * * TIB_TO_TCB(tib) * Given a TIB pointer, return the matching TCB pointer * * TIB_INIT(tib, dtv, thread) * Initializes a TIB for a new thread, using the supplied * values for its dtv and thread pointers * * TIB_GET() * Short-hand for TCB_TO_TIB(TCB_GET()) * * TIB_EXTRA_ALIGN * On TLS variant 2 archs, what alignment is sufficient * for the extra space that will be used for struct pthread? * * The following functions are provided by either ld.so (dynamic) or * libc (static) for allocating and freeing a common memory block that * will hold both the TIB and the pthread structure: * _dl_allocate_tib(sizeof(struct pthread)) * Allocates a combined TIB and pthread memory region. * The argument is the amount of space to reserve * for the pthread structure. Returns a pointer to * the TIB inside the allocated block. * * _dl_free_tib(tib, sizeof(struct pthread)) * Frees a TIB and pthread block previously allocated * with _dl_allocate_tib(). Must be passed the return * value of that previous call. */ /* * Regarding <machine/tcb.h>: * - it must define the TLS_VARIANT macro * - it may define TCB_OFFSET if the TCB address in the kernel and/or * register is offset from the actual TCB address. TCB_OFFSET > 0 * means the kernel/register points to *after* the real data. * - if there's a faster way to get or set the TCB pointer for the thread * than the __{get,set}_tcb() syscalls, it should define either or both * the TCB_{GET,SET} macros to do so. */ /* All archs but mips64 have fast TCB_GET() and don't need caching */ #ifndef __mips64__ # define TCB_HAVE_MD_GET 1 #endif #ifdef TCB_SET # define TCB_HAVE_MD_SET 1 #else # define TCB_SET(tcb) __set_tcb(tcb) #endif #ifndef TCB_OFFSET # define TCB_OFFSET 0 #endif /* * tib_cantcancel values is non-zero if the thread should skip all * cancellation processing */ #define CANCEL_DISABLED 1 #define CANCEL_DYING 2 /* * tib_cancel_point is non-zero if we're in a cancel point; its modified * by the cancel point code and read by the cancellation signal handler */ #define CANCEL_POINT 1 #define CANCEL_POINT_DELAYED 2 #if TLS_VARIANT == 1 /* * ABI specifies that the static TLS data starts two words after the * (notional) thread pointer, with the first of those two words being * the TLS dtv pointer. The other (second) word is reserved for the * implementation, so we place the pointer to the thread structure there, * but we place our actual thread bits before the TCB, at negative offsets * from the TCB pointer. Ergo, memory is laid out, low to high, as: * * [pthread structure] * TIB { * ...cancelation and other int-sized info... * int errno * void *locale * TCB (- TCB_OFFSET) { * void *dtv * struct pthread *thread * } * } * static TLS data */ struct tib { void *tib_atexit; int tib_thread_flags; /* internal to libpthread */ pid_t tib_tid; int tib_cantcancel; int tib_cancel_point; int tib_canceled; int tib_errno; void *tib_locale; #ifdef __powerpc64__ void *tib_thread; void *tib_dtv; /* internal to the runtime linker */ #else void *tib_dtv; /* internal to the runtime linker */ void *tib_thread; #endif }; #elif TLS_VARIANT == 2 /* * ABI specifies that the static TLS data occupies the memory before * the TCB pointer, at negative offsets, and that on i386 and amd64 * the word the TCB points to contains a pointer to itself. So, * we place errno and our thread bits after that. Memory is laid * out, low to high, as: * static TLS data * TIB { * TCB (- TCB_OFFSET) { * self pointer [i386/amd64 only] * void *dtv * } * struct pthread *thread * void *locale * int errno * ...cancelation and other int-sized info... * } * [pthread structure] */ struct tib { #if defined(__i386) || defined(__amd64) struct tib *__tib_self; # define __tib_tcb __tib_self #endif void *tib_dtv; /* internal to the runtime linker */ void *tib_thread; void *tib_locale; int tib_errno; int tib_canceled; int tib_cancel_point; int tib_cantcancel; pid_t tib_tid; int tib_thread_flags; /* internal to libpthread */ void *tib_atexit; }; #if defined(__i386) || defined(__amd64) # define _TIB_PREP(tib) \ ((void)((tib)->__tib_self = (tib))) #endif #define TIB_EXTRA_ALIGN sizeof(void *) #else # error "unknown TLS variant" #endif /* nothing to do by default */ #ifndef _TIB_PREP # define _TIB_PREP(tib) ((void)0) #endif #define TIB_INIT(tib, dtv, thread) do { \ (tib)->tib_thread = (thread); \ (tib)->tib_atexit = NULL; \ (tib)->tib_locale = NULL; \ (tib)->tib_cantcancel = 0; \ (tib)->tib_cancel_point = 0; \ (tib)->tib_canceled = 0; \ (tib)->tib_dtv = (dtv); \ (tib)->tib_errno = 0; \ (tib)->tib_thread_flags = 0; \ _TIB_PREP(tib); \ } while (0) #ifndef __tib_tcb # define __tib_tcb tib_dtv #endif #define _TIBO_TCB (offsetof(struct tib, __tib_tcb) + TCB_OFFSET) #define TCB_TO_TIB(tcb) ((struct tib *)((char *)(tcb) - _TIBO_TCB)) #define TIB_TO_TCB(tib) ((char *)(tib) + _TIBO_TCB) #define TIB_GET() TCB_TO_TIB(TCB_GET()) __BEGIN_DECLS struct dl_info; struct dl_phdr_info; struct dl_cb_0 { void *(*dl_allocate_tib)(size_t); void (*dl_free_tib)(void *, size_t); void (*dl_clean_boot)(void); void *(*dlopen)(const char *, int); int (*dlclose)(void *); void *(*dlsym)(void *, const char *); int (*dladdr)(const void *, struct dl_info *); int (*dlctl)(void *, int, void *); char *(*dlerror)(void); int (*dl_iterate_phdr)(int (*)(struct dl_phdr_info *, size_t, void *), void *); }; #define DL_CB_CUR 0 typedef struct dl_cb_0 dl_cb; /* type of function passed to init functions that returns a dl_cb */ typedef const void *dl_cb_cb(int _version); void *_dl_allocate_tib(size_t _extra) __dso_public; void _dl_free_tib(void *_tib, size_t _extra) __dso_public; /* The actual syscalls */ void *__get_tcb(void); void __set_tcb(void *_tcb); __END_DECLS #endif /* _TIB_H_ */
