sysdeps/mach/hurd/i386/tls.h

   1 /* Definitions for thread-local data handling.  Hurd/i386 version.
   2    Copyright (C) 2003-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #ifndef _I386_TLS_H
  20 #define _I386_TLS_H
  21
  22
  23 /* Some things really need not be machine-dependent.  */
  24 #include <sysdeps/mach/hurd/tls.h>
  25
  26
  27 #ifndef __ASSEMBLER__
  28 # include <dl-dtv.h>
  29
  30 /* Type of the TCB.  */
  31 typedef struct
  32 {
  33   void *tcb;                    /* Points to this structure.  */
  34   dtv_t *dtv;                   /* Vector of pointers to TLS data.  */
  35   thread_t self;                /* This thread's control port.  */
  36   int multiple_threads;
  37   uintptr_t sysinfo;
  38   uintptr_t stack_guard;
  39   uintptr_t pointer_guard;
  40   int gscope_flag;
  41   int private_futex;
  42   /* Reservation of some values for the TM ABI.  */
  43   void *__private_tm[4];
  44   /* GCC split stack support.  */
  45   void *__private_ss;
  46
  47   /* Keep these fields last, so offsets of fields above can continue being
  48      compatible with the i386 Linux version.  */
  49   mach_port_t reply_port;      /* This thread's reply port.  */
  50   struct hurd_sigstate *_hurd_sigstate;
  51
  52   /* Used by the exception handling implementation in the dynamic loader.  */
  53   struct rtld_catch *rtld_catch;
  54 } tcbhead_t;
  55
  56 /* Return tcbhead_t from a TLS segment descriptor.  */
  57 # define HURD_DESC_TLS(desc)                                                  \
  58   ({                                                                          \
  59    (tcbhead_t *) (   (desc->low_word >> 16)                                   \
  60                   | ((desc->high_word & 0xff) << 16)                          \
  61                   |  (desc->high_word & 0xff000000));                         \
  62   })
  63
  64 /* Return 1 if TLS is not initialized yet.  */
  65 #ifndef SHARED
  66 extern unsigned short __init1_desc;
  67 #define __HURD_DESC_INITIAL(gs, ds) ((gs) == (ds) || (gs) == __init1_desc)
  68 #else
  69 #define __HURD_DESC_INITIAL(gs, ds) ((gs) == (ds))
  70 #endif
  71
  72 #define __LIBC_NO_TLS()                                                       \
  73   ({ unsigned short ds, gs;                                                   \
  74      asm ("movw %%ds,%w0; movw %%gs,%w1" : "=q" (ds), "=q" (gs));             \
  75      __builtin_expect(__HURD_DESC_INITIAL(gs, ds), 0); })
  76 #endif
  77
  78 /* The TCB can have any size and the memory following the address the
  79    thread pointer points to is unspecified.  Allocate the TCB there.  */
  80 #define TLS_TCB_AT_TP   1
  81 #define TLS_DTV_AT_TP   0
  82
  83 /* Alignment requirement for TCB.
  84
  85    Some processors such as Intel Atom pay a big penalty on every
  86    access using a segment override if that segment's base is not
  87    aligned to the size of a cache line.  (See Intel 64 and IA-32
  88    Architectures Optimization Reference Manual, section 13.3.3.3,
  89    "Segment Base".)  On such machines, a cache line is 64 bytes.  */
  90 #define TCB_ALIGNMENT           64
  91
  92 #ifndef __ASSEMBLER__
  93
  94 /* Use i386-specific RPCs to arrange that %gs segment register prefix
  95    addresses the TCB in each thread.  */
  96 # include <mach/i386/mach_i386.h>
  97
  98 # ifndef HAVE_I386_SET_GDT
  99 #  define __i386_set_gdt(thr, sel, desc) ((void) (thr), (void) (sel), (void) (desc), MIG_BAD_ID)
 100 # endif
 101
 102 # include <errno.h>
 103 # include <assert.h>
 104
 105 # define HURD_TLS_DESC_DECL(desc, tcb)                                        \
 106   struct descriptor desc =                                                    \
 107     {                           /* low word: */                               \
 108       0xffff                    /* limit 0..15 */                             \
 109       | (((unsigned int) (tcb)) << 16) /* base 0..15 */                       \
 110       ,                         /* high word: */                              \
 111       ((((unsigned int) (tcb)) >> 16) & 0xff) /* base 16..23 */               \
 112       | ((0x12 | 0x60 | 0x80) << 8) /* access = ACC_DATA_W|ACC_PL_U|ACC_P */  \
 113       | (0xf << 16)             /* limit 16..19 */                            \
 114       | ((4 | 8) << 20)         /* granularity = SZ_32|SZ_G */                \
 115       | (((unsigned int) (tcb)) & 0xff000000) /* base 24..31 */               \
 116     }
 117
 118 # define HURD_SEL_LDT(sel) (__builtin_expect ((sel) & 4, 0))
 119
 120 static inline bool __attribute__ ((unused))
 121 _hurd_tls_init (tcbhead_t *tcb)
 122 {
 123   HURD_TLS_DESC_DECL (desc, tcb);
 124   thread_t self = __mach_thread_self ();
 125   bool success = true;
 126
 127   /* This field is used by TLS accesses to get our "thread pointer"
 128      from the TLS point of view.  */
 129   tcb->tcb = tcb;
 130   /* We always at least start the sigthread anyway.  */
 131   tcb->multiple_threads = 1;
 132
 133   /* Get the first available selector.  */
 134   int sel = -1;
 135   error_t err = __i386_set_gdt (self, &sel, desc);
 136   if (err == MIG_BAD_ID)
 137     {
 138       /* Old kernel, use a per-thread LDT.  */
 139       sel = 0x27;
 140       err = __i386_set_ldt (self, sel, &desc, 1);
 141       assert_perror (err);
 142       if (err)
 143       {
 144         success = false;
 145         goto out;
 146       }
 147     }
 148   else if (err)
 149     {
 150       assert_perror (err); /* Separate from above with different line #. */
 151       success = false;
 152       goto out;
 153     }
 154
 155   /* Now install the new selector.  */
 156   asm volatile ("mov %w0, %%gs" :: "q" (sel));
 157
 158 out:
 159   __mach_port_deallocate (__mach_task_self (), self);
 160   return success;
 161 }
 162
 163 /* Code to initially initialize the thread pointer.  This might need
 164    special attention since 'errno' is not yet available and if the
 165    operation can cause a failure 'errno' must not be touched.  */
 166 # define TLS_INIT_TP(descr) \
 167     _hurd_tls_init ((tcbhead_t *) (descr))
 168
 169 /* Return the TCB address of the current thread.  */
 170 # define THREAD_SELF                                                          \
 171   ({ tcbhead_t *__tcb;                                                        \
 172      __asm__ ("movl %%gs:%c1,%0" : "=r" (__tcb)                               \
 173               : "i" (offsetof (tcbhead_t, tcb)));                             \
 174      __tcb;})
 175
 176 /* Read member of the thread descriptor directly.  */
 177 # define THREAD_GETMEM(descr, member) \
 178   ({ __typeof (descr->member) __value;                                        \
 179      _Static_assert (sizeof (__value) == 1                                    \
 180                      || sizeof (__value) == 4                                 \
 181                      || sizeof (__value) == 8,                                \
 182                      "size of per-thread data");                              \
 183      if (sizeof (__value) == 1)                                               \
 184        asm volatile ("movb %%gs:%P2,%b0"                                      \
 185                      : "=q" (__value)                                         \
 186                      : "0" (0), "i" (offsetof (tcbhead_t, member)));          \
 187      else if (sizeof (__value) == 4)                                          \
 188        asm volatile ("movl %%gs:%P1,%0"                                       \
 189                      : "=r" (__value)                                         \
 190                      : "i" (offsetof (tcbhead_t, member)));                   \
 191      else /* 8 */                                                             \
 192        {                                                                      \
 193          asm volatile ("movl %%gs:%P1,%%eax\n\t"                              \
 194                        "movl %%gs:%P2,%%edx"                                  \
 195                        : "=A" (__value)                                       \
 196                        : "i" (offsetof (tcbhead_t, member)),                  \
 197                          "i" (offsetof (tcbhead_t, member) + 4));             \
 198        }                                                                      \
 199      __value; })
 200
 201
 202 /* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
 203 # define THREAD_GETMEM_NC(descr, member, idx) \
 204   ({ __typeof (descr->member[0]) __value;                                     \
 205      _Static_assert (sizeof (__value) == 1                                    \
 206                      || sizeof (__value) == 4                                 \
 207                      || sizeof (__value) == 8,                                \
 208                      "size of per-thread data");                              \
 209      if (sizeof (__value) == 1)                                               \
 210        asm volatile ("movb %%gs:%P2(%3),%b0"                                  \
 211                      : "=q" (__value)                                         \
 212                      : "0" (0), "i" (offsetof (tcbhead_t, member[0])),        \
 213                      "r" (idx));                                              \
 214      else if (sizeof (__value) == 4)                                          \
 215        asm volatile ("movl %%gs:%P1(,%2,4),%0"                                \
 216                      : "=r" (__value)                                         \
 217                      : "i" (offsetof (tcbhead_t, member[0])),                 \
 218                        "r" (idx));                                            \
 219      else /* 8 */                                                             \
 220        {                                                                      \
 221          asm volatile  ("movl %%gs:%P1(,%2,8),%%eax\n\t"                      \
 222                         "movl %%gs:4+%P1(,%2,8),%%edx"                        \
 223                         : "=&A" (__value)                                     \
 224                         : "i" (offsetof (tcbhead_t, member[0])),              \
 225                           "r" (idx));                                         \
 226        }                                                                      \
 227      __value; })
 228
 229
 230
 231 /* Set member of the thread descriptor directly.  */
 232 # define THREAD_SETMEM(descr, member, value) \
 233   ({                                                                          \
 234      _Static_assert (sizeof (descr->member) == 1                              \
 235                      || sizeof (descr->member) == 4                           \
 236                      || sizeof (descr->member) == 8,                          \
 237                      "size of per-thread data");                              \
 238      if (sizeof (descr->member) == 1)                                         \
 239        asm volatile ("movb %b0,%%gs:%P1" :                                    \
 240                      : "iq" (value),                                          \
 241                        "i" (offsetof (tcbhead_t, member)));                   \
 242      else if (sizeof (descr->member) == 4)                                    \
 243        asm volatile ("movl %0,%%gs:%P1" :                                     \
 244                      : "ir" (value),                                          \
 245                        "i" (offsetof (tcbhead_t, member)));                   \
 246      else /* 8 */                                                             \
 247        {                                                                      \
 248          asm volatile ("movl %%eax,%%gs:%P1\n\t"                              \
 249                        "movl %%edx,%%gs:%P2" :                                \
 250                        : "A" ((uint64_t) cast_to_integer (value)),            \
 251                          "i" (offsetof (tcbhead_t, member)),                  \
 252                          "i" (offsetof (tcbhead_t, member) + 4));             \
 253        }})
 254
 255
 256 /* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
 257 # define THREAD_SETMEM_NC(descr, member, idx, value) \
 258   ({                                                                          \
 259      _Static_assert (sizeof (descr->member[0]) == 1                           \
 260                      || sizeof (descr->member[0]) == 4                        \
 261                      || sizeof (descr->member[0]) == 8,                       \
 262                      "size of per-thread data");                              \
 263      if (sizeof (descr->member[0]) == 1)                                      \
 264        asm volatile ("movb %b0,%%gs:%P1(%2)" :                                \
 265                      : "iq" (value),                                          \
 266                        "i" (offsetof (tcbhead_t, member)),                    \
 267                        "r" (idx));                                            \
 268      else if (sizeof (descr->member[0]) == 4)                                 \
 269        asm volatile ("movl %0,%%gs:%P1(,%2,4)" :                              \
 270                      : "ir" (value),                                          \
 271                        "i" (offsetof (tcbhead_t, member)),                    \
 272                        "r" (idx));                                            \
 273      else /* 8 */                                                             \
 274        {                                                                      \
 275          asm volatile ("movl %%eax,%%gs:%P1(,%2,8)\n\t"                       \
 276                        "movl %%edx,%%gs:4+%P1(,%2,8)" :                       \
 277                        : "A" ((uint64_t) cast_to_integer (value)),            \
 278                          "i" (offsetof (tcbhead_t, member)),                  \
 279                          "r" (idx));                                          \
 280        }})
 281
 282 /* Return the TCB address of a thread given its state.
 283    Note: this is expensive.  */
 284 # define THREAD_TCB(thread, thread_state)                                     \
 285   ({ int __sel = (thread_state)->basic.gs;                                    \
 286      struct descriptor __desc, *___desc = &__desc;                            \
 287      unsigned int __count = 1;                                                \
 288      kern_return_t __err;                                                     \
 289      if (HURD_SEL_LDT (__sel))                                                \
 290        __err = __i386_get_ldt ((thread), __sel, 1, &___desc, &__count);       \
 291      else                                                                     \
 292        __err = __i386_get_gdt ((thread), __sel, &__desc);                     \
 293      assert_perror (__err);                                                   \
 294      assert (__count == 1);                                                   \
 295      HURD_DESC_TLS (___desc);})
 296
 297 /* Install new dtv for current thread.  */
 298 # define INSTALL_NEW_DTV(dtvp)                                                \
 299   ({ asm volatile ("movl %0,%%gs:%P1"                                         \
 300                    : : "ir" (dtvp), "i" (offsetof (tcbhead_t, dtv))); })
 301
 302 /* Return the address of the dtv for the current thread.  */
 303 # define THREAD_DTV()                                                         \
 304   ({ dtv_t *_dtv;                                                             \
 305      asm ("movl %%gs:%P1,%0" : "=q" (_dtv) : "i" (offsetof (tcbhead_t, dtv)));\
 306      _dtv; })
 307
 308
 309 /* Set the stack guard field in TCB head.  */
 310 #define THREAD_SET_STACK_GUARD(value) \
 311   THREAD_SETMEM (THREAD_SELF, stack_guard, value)
 312 #define THREAD_COPY_STACK_GUARD(descr) \
 313   ((descr)->stack_guard                                                       \
 314    = THREAD_GETMEM (THREAD_SELF, stack_guard))
 315
 316 /* Set the pointer guard field in the TCB head.  */
 317 #define THREAD_SET_POINTER_GUARD(value) \
 318   THREAD_SETMEM (THREAD_SELF, pointer_guard, value)
 319 #define THREAD_COPY_POINTER_GUARD(descr) \
 320   ((descr)->pointer_guard                                                     \
 321    = THREAD_GETMEM (THREAD_SELF, pointer_guard))
 322
 323
 324 # include <mach/machine/thread_status.h>
 325
 326 /* Set up TLS in the new thread of a fork child, copying from the original.  */
 327 static inline kern_return_t __attribute__ ((unused))
 328 _hurd_tls_fork (thread_t child, thread_t orig, struct i386_thread_state *state)
 329 {
 330   /* Fetch the selector set by _hurd_tls_init.  */
 331   int sel;
 332   asm ("mov %%gs, %w0" : "=q" (sel) : "0" (0));
 333   if (sel == state->ds)         /* _hurd_tls_init was never called.  */
 334     return 0;
 335
 336   struct descriptor desc, *_desc = &desc;
 337   error_t err;
 338   unsigned int count = 1;
 339
 340   if (HURD_SEL_LDT (sel))
 341     err = __i386_get_ldt (orig, sel, 1, &_desc, &count);
 342   else
 343     err = __i386_get_gdt (orig, sel, &desc);
 344
 345   assert_perror (err);
 346   if (err)
 347     return err;
 348
 349   if (HURD_SEL_LDT (sel))
 350     err = __i386_set_ldt (child, sel, &desc, 1);
 351   else
 352     err = __i386_set_gdt (child, &sel, desc);
 353
 354   state->gs = sel;
 355   return err;
 356 }
 357
 358 static inline kern_return_t __attribute__ ((unused))
 359 _hurd_tls_new (thread_t child, struct i386_thread_state *state, tcbhead_t *tcb)
 360 {
 361   /* Fetch the selector set by _hurd_tls_init.  */
 362   int sel;
 363   asm ("mov %%gs, %w0" : "=q" (sel) : "0" (0));
 364   if (sel == state->ds)         /* _hurd_tls_init was never called.  */
 365     return 0;
 366
 367   HURD_TLS_DESC_DECL (desc, tcb);
 368   error_t err;
 369
 370   tcb->tcb = tcb;
 371   tcb->self = child;
 372
 373   if (HURD_SEL_LDT (sel))
 374     err = __i386_set_ldt (child, sel, &desc, 1);
 375   else
 376     err = __i386_set_gdt (child, &sel, desc);
 377
 378   state->gs = sel;
 379   return err;
 380 }
 381
 382 /* Global scope switch support.  */
 383 # define THREAD_GSCOPE_FLAG_UNUSED 0
 384 # define THREAD_GSCOPE_FLAG_USED   1
 385 # define THREAD_GSCOPE_FLAG_WAIT   2
 386
 387 # define THREAD_GSCOPE_SET_FLAG() \
 388   THREAD_SETMEM (THREAD_SELF, gscope_flag, THREAD_GSCOPE_FLAG_USED)
 389
 390 # define THREAD_GSCOPE_RESET_FLAG() \
 391   ({                                                                         \
 392     int __flag;                                                              \
 393     asm volatile ("xchgl %0, %%gs:%P1"                                       \
 394                   : "=r" (__flag)                                            \
 395                   : "i" (offsetof (tcbhead_t, gscope_flag)),                 \
 396                     "0" (THREAD_GSCOPE_FLAG_UNUSED));                        \
 397     if (__flag == THREAD_GSCOPE_FLAG_WAIT)                                   \
 398       lll_wake (THREAD_SELF->gscope_flag, LLL_PRIVATE);                      \
 399   })
 400
 401 #endif  /* !__ASSEMBLER__ */
 402
 403 #endif  /* i386/tls.h */