Changeset 1287

Timestamp:

Mar 11, 2004, 4:05:55 AM (21 years ago)

Author:

bird

Message:

#967: Initial per thread data rewrite.

Location:

trunk/src/emx

Files:

• include/InnoTekLIBC/backend.h (added)
• include/InnoTekLIBC/thread.h (added)
• include/emx/syscalls.h (modified) (3 diffs, 1 prop)
• include/emx/thread.h (modified) (1 diff, 1 prop)
• include/emx/umalloc.h (modified) (1 diff, 1 prop)
• src/lib/io/tmpnam.c (modified) (2 diffs, 1 prop)
• src/lib/io/ttyname.c (modified) (1 diff, 1 prop)
• src/lib/libc.def (modified) (7 diffs, 1 prop)
• src/lib/malloc/calloc.c (modified) (1 diff, 1 prop)
• src/lib/malloc/heapchk.c (modified) (1 diff, 1 prop)
• src/lib/malloc/heapmin.c (modified) (1 diff, 1 prop)
• src/lib/malloc/heapset.c (modified) (1 diff, 1 prop)
• src/lib/malloc/heapwalk.c (modified) (1 diff, 1 prop)
• src/lib/malloc/initr.c (modified) (1 diff, 1 prop)
• src/lib/malloc/initt.c (modified) (1 diff, 1 prop)
• src/lib/malloc/malloc.c (modified) (1 diff, 1 prop)
• src/lib/malloc/posix_memalign.c (modified) (1 diff, 1 prop)
• src/lib/malloc/tcalloc.c (modified) (1 diff, 1 prop)
• src/lib/malloc/theapmin.c (modified) (1 diff, 1 prop)
• src/lib/malloc/tmalloc.c (modified) (1 diff, 1 prop)
• src/lib/malloc/trealloc.c (modified) (1 diff, 1 prop)
• src/lib/malloc/udefault.c (modified) (1 diff, 1 prop)
• src/lib/malloc/utdefaul.c (modified) (1 diff, 1 prop)
• src/lib/misc/getvol.c (modified) (3 diffs, 1 prop)
• src/lib/misc/rand.c (modified) (1 diff, 1 prop)
• src/lib/process/386/_errno.s (modified) (1 diff, 1 prop)
• src/lib/process/386/thread.s (deleted)
• src/lib/process/beginthr.c (modified) (2 diffs, 1 prop)
• src/lib/process/thread_internals.c (added)
• src/lib/process/threadst.c (modified) (1 diff, 1 prop)
• src/lib/startup/startup.c (modified) (2 diffs, 1 prop)
• src/lib/str/strerror.c (modified) (2 diffs, 1 prop)
• src/lib/str/strerror_r.c (modified) (1 diff, 1 prop)
• src/lib/str/strtok.c (modified) (4 diffs, 1 prop)
• src/lib/sys/386/systhrea.s (deleted)
• src/lib/sys/__endthread.c (deleted)
• src/lib/sys/__init.c (modified) (9 diffs, 1 prop)
• src/lib/sys/__initdll.c (modified) (5 diffs, 1 prop)
• src/lib/sys/__initthread.c (deleted)
• src/lib/sys/__newthread.c (deleted)
• src/lib/sys/b_threadCleanup.c (added)
• src/lib/sys/b_threadEnd.c (added)
• src/lib/sys/b_threadInit.c (added)
• src/lib/sys/b_threadStartup.c (added)
• src/lib/sys/filefind.c (modified) (4 diffs, 1 prop)
• src/lib/sys/raise.c (modified) (1 diff, 1 prop)
• src/lib/sys/sigaction.c (modified) (1 diff, 1 prop)
• src/lib/sys/signal.c (modified) (1 diff, 1 prop)
• src/lib/sys/sigpending.c (modified) (1 diff, 1 prop)
• src/lib/sys/sigprocmask.c (modified) (1 diff, 1 prop)
• src/lib/sys/sigsuspend.c (modified) (1 diff, 1 prop)
• src/lib/sys/syscalls.h (modified) (3 diffs, 1 prop)
• src/lib/sys/tls.c (added)
• src/lib/time/asctime.c (modified) (2 diffs, 1 prop)
• src/lib/time/gmtime.c (modified) (2 diffs, 1 prop)
• src/lib/time/localtim.c (modified) (1 diff, 1 prop)
• testcase/loadthread2.c (modified) (1 diff, 1 prop)
• version.smak (modified) (1 diff, 1 prop)

trunk/src/emx/include/emx/syscalls.h

@@ -136 +136 @@
 int __dup (int handle);
 int __dup2 (int handle1, int handle2);
-int __endthread (int tid);
+int __endthread (void *pvThrd);
 int __execname (char *buf, size_t bufsize);
 void __exit (int ret) __attribute__ ((__noreturn__));
@@ -171 +171 @@
 int __imphandle (int handle);
 int __impsockhandle (int handle, int flags);
-int __initthread (void *preg);
 int __ioctl1 (int handle, int code);
 int __ioctl2 (int handle, unsigned long request, int arg);
@@ -226 +225 @@
 int __write (int handle, __const__ void *buf, size_t nbyte);
 
-
-
 #if defined (__cplusplus)
 }

trunk/src/emx/include/emx/thread.h

@@ -1 @@
-/* emx/thread.h (emx+gcc) */
-
-#ifndef _EMX_THREAD_H
-#define _EMX_THREAD_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-#include <time.h> /* struct tm; */
-
-struct _uheap;
-
-struct _thread
-{
-  int             _th_errno;                /* comes first, cf. errnofun.s */
-  void          * _th_arg;
-  void          (*_th_start)(void *);
-  unsigned char * _th_strtok_ptr;
-  char            _th_asctime_buf[26+2];    /* 2 chars for padding */
-  char            _th_tmpnam_buf[16];       /* cf. stdio.h */
-  struct tm       _th_gmtime_buf;
-  unsigned int    _th_rand;                 /* Used by rand() */
-  void          * _th_store;                /* Pointer to user data */
-  char            _th_vollabel[12];         /* Used by _getvol() */
-  char            _th_error[28];            /* Used by strerror() */
-  struct _uheap * _th_rheap;                /* Default regular heap */
-  struct _uheap * _th_theap;                /* Default tiled heap */
-  char            _th_ttyname[32];          /* Used by ttyname() */
-  char            _th_inetntoa[16];         /* Used by inetntoa() */
-  int             _th_reserved[974];        /* 4096 bytes, total */
-};
-
-struct _thread *_thread (void);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* not _EMX_THREAD_H */
+#error "This file is dead. use InnoTekLIBC/thread.h!"

trunk/src/emx/include/emx/umalloc.h

@@ -606 +606 @@
 /* Each thread has its own default heap. */
 
-#define _UM_DEFAULT_REGULAR_HEAP tp->_th_rheap
-#define _UM_DEFAULT_TILED_HEAP   tp->_th_theap
-#define _UM_MT_DECL              struct _thread *tp = _thread ();
+#define _UM_DEFAULT_REGULAR_HEAP pThrd->pRegularHeap
+#define _UM_DEFAULT_TILED_HEAP   pThrd->pTiledHeap
+#define _UM_MT_DECL              __LIBC_PTHREAD pThrd = __libc_threadCurrent();
 
 /* Note that _um_regular_heap is declared in <umalloc.h>.

trunk/src/emx/src/lib/io/tmpnam.c

@@ -4 +4 @@
 #include "libc-alias.h"
 #include <stdio.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include "_tmp.h"
 
@@ -12 +12 @@
   if (string == NULL)
     {
-      struct _thread *tp = _thread ();
-      string = tp->_th_tmpnam_buf;
+      __LIBC_PTHREAD pThrd = __libc_threadCurrent ();
+      string = pThrd->szTmpNamBuf;
     }
   if (_tmpidxnam (string) >= 0)

trunk/src/emx/src/lib/io/ttyname.c

@@ -4 +4 @@
 #include <unistd.h>
 #include <emx/syscalls.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 char *_STD(ttyname) (int handle)
 {
-  struct _thread *tp = _thread ();
+  __LIBC_PTHREAD pThrd = __libc_threadCurrent ();
 
-  if (__ttyname (handle, tp->_th_ttyname, sizeof (tp->_th_ttyname)) == 0)
-    return tp->_th_ttyname;
+  if (__ttyname (handle, pThrd->szTTYNameBuf, sizeof (pThrd->szTTYNameBuf)) == 0)
+    return pThrd->szTTYNameBuf;
   else
     return NULL;

trunk/src/emx/src/lib/libc.def

@@ -46 +46 @@
     "__streamv_rmutex" @26
     "__streamvec_head" @27
-    "__thread_tab" @28
+; fixme "" @28
     "__tmpidx" @29
     "__tzi" @30
@@ -76 +76 @@
     "__HUGE_VAL" @103
     "__LHUGE_VAL" @104
-    "___alloc_thread" @105
+; fixme    "___alloc_thread" @105
     "___atod" @106
     "___chdir" @107
@@ -89 +89 @@
     "___dup" @116
     "___dup2" @117
-    "___endthread" @118
+; fixme    "___endthread" @118
     "___exit" @119
     "___fcntl" @120
@@ -110 +110 @@
     "___init_app" @137
     "___init_dll" @138
-    "___initthread" @139
+; fixme    "___initthread" @139
     "___ioctl1" @140
     "___ioctl2" @141
@@ -134 +134 @@
     "___lseek" @161
     "___mkdir" @162
-    "___newthread" @163
+; fixme    "___newthread" @163
     "___open" @164
     "___pipe" @165
@@ -741 +741 @@
     "__swchar" @768
     "__sys_dump_heap_objs" @769
-    "__sys_exception" @770
+    "_sys_exception" @770
     "__tcalloc" @771
     "__tfree" @772
     "__theapmin" @773
-    "__thread" @774
+; fixme    "__thread" @774
     "__threadstore" @775
     "__tmalloc" @776
@@ -1078 +1078 @@
     "___umoddi3"                                @1103
     "__alloca"                                  @1104
+    "__std_usleep" @1105
 
-    "__std_usleep" @1105
+    "___libc_Back_threadCleanup" @1106
+    "___libc_Back_threadEnd" @1107
+    "___libc_Back_threadInit" @1108
+    "___libc_Back_threadStartup" @1109
+    "___libc_TLSAlloc" @1110
+    "___libc_TLSFree" @1111
+    "___libc_TLSGet" @1112
+    "___libc_TLSSet" @1113

trunk/src/emx/src/lib/malloc/calloc.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 void *_STD(calloc) (size_t count, size_t size)

trunk/src/emx/src/lib/malloc/heapchk.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 int _heapchk (void)

trunk/src/emx/src/lib/malloc/heapmin.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 int _heapmin (void)

trunk/src/emx/src/lib/malloc/heapset.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 int _heapset (unsigned fill)

trunk/src/emx/src/lib/malloc/heapwalk.c

@@ -5 +5 @@
 #include <umalloc.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 int _heap_walk (_um_callback1 *callback)

trunk/src/emx/src/lib/malloc/initr.c

@@ -5 +5 @@
 #include <emx/umalloc.h>
 #include <sys/smutex.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 /** This is the default regular heap. */

trunk/src/emx/src/lib/malloc/initt.c

@@ -4 +4 @@
 #include <emx/umalloc.h>
 #include <sys/smutex.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 /** This is the default tiled heap. */

trunk/src/emx/src/lib/malloc/malloc.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 void *_STD(malloc) (size_t size)

trunk/src/emx/src/lib/malloc/posix_memalign.c

@@ -28 +28 @@
 #include <umalloc.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include <assert.h>
 

trunk/src/emx/src/lib/malloc/tcalloc.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 void *_tcalloc (size_t count, size_t size)

trunk/src/emx/src/lib/malloc/theapmin.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 int _theapmin (void)

trunk/src/emx/src/lib/malloc/tmalloc.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 void *_tmalloc (size_t size)

trunk/src/emx/src/lib/malloc/trealloc.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 void *_trealloc (void *block, size_t new_size)

trunk/src/emx/src/lib/malloc/udefault.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 Heap_t _udefault (Heap_t h)

trunk/src/emx/src/lib/malloc/utdefaul.c

@@ -9 +9 @@
 #include <sys/rmutex.h>
 #include <emx/umalloc.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 Heap_t _utdefault (Heap_t h)

trunk/src/emx/src/lib/misc/getvol.c

@@ -4 +4 @@
 #include <stdlib.h>
 #include <string.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include <emx/syscalls.h>
 #define INCL_DOSFILEMGR
@@ -13 +13 @@
 char *_getvol (char drive)
 {
-  struct _thread *tp = _thread();
+  __LIBC_PTHREAD pThrd = __libc_threadCurrent();
   FS_VAR();
 
@@ -33 +33 @@
   if (rc != 0)
     return NULL;
-  strcpy (tp->_th_vollabel, fsinfo.vol.szVolLabel);
-
-  return tp->_th_vollabel;
+  return strcpy (pThrd->szVolLabelBuf, fsinfo.vol.szVolLabel);
 }

trunk/src/emx/src/lib/misc/rand.c

@@ -3 +3 @@
 #include "libc-alias.h"
 #include <stdlib.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 int _STD(rand) (void)
 {
-  struct _thread *tp = _thread();
-  tp->_th_rand = tp->_th_rand * 69069 + 5;
-  return (tp->_th_rand >> 16) & 0x7fff;
+  __LIBC_PTHREAD pThrd = __libc_threadCurrent();
+  pThrd->iRand = pThrd->iRand * 69069 + 5;
+  return (pThrd->iRand >> 16) & 0x7fff;
 }
 
 void _STD(srand) (unsigned int seed)
 {
-  struct _thread *tp = _thread();
-  tp->_th_rand = seed;
+  __LIBC_PTHREAD pThrd = __libc_threadCurrent();
+  pThrd->iRand = seed;
 }

trunk/src/emx/src/lib/process/386/_errno.s

@@ -12 +12 @@
 __errno:
 __errno_fun:
-        fs
-        movl    12, %eax                /* ptib2 */
-        movl    0(%eax), %eax           /* TID */
-        movl    __thread_tab(,%eax,4), %eax
-/       addl    $0, %eax                /* address of errno */
+    movl    ___libc_gpTLS, %eax
+    movl    (%eax), %eax
+    orl     %eax, %eax
+    jnz     done
+    call    ___libc_threadCurrentSlow
+done:
         EPILOGUE(_errno)

trunk/src/emx/src/lib/process/beginthr.c

@@ -5 +5 @@
 #include <string.h>
 #include <errno.h>
-#include <emx/thread.h>
-#include <emx/syscalls.h>
 #define INCL_DOSPROCESS
 #define INCL_DOSERRORS
@@ -12 +10 @@
 #define INCL_FSMACROS
 #include <os2emx.h>
-
-#define MAX_THREADS 1024
-
-static struct _thread thread_1 =
-{
-  0,                            /* _th_errno */
-  NULL,                         /* _th_arg */
-  NULL,                         /* _th_start */
-  NULL,                         /* _th_strtok_ptr (must be NULL) */
-  {0},                          /* _th_asctime_buf */
-  {0},                          /* _th_tmpnam_buf */
-  {0},                          /* _th_gmtime_buf */
-  1,                            /* _th_rand */
-  NULL,                         /* _th_store */
-  "",                           /* _th_vollabel */
-  "",                           /* _th_error */
-  NULL,                         /* _th_rheap */
-  NULL,                         /* _th_theap */
-  ""                            /* _th_ttyname */
-};
-
-struct _thread *_thread_tab[MAX_THREADS+1] = {NULL, &thread_1};
+#include <emx/syscalls.h>
+#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
 
 
-struct _thread *__alloc_thread (void); /* used in thread.s */
+/**
+ * Thread wrapper routine.
+ *
+ * @param   pThrd   Pointer to thread structure allocated for this thread.
+ */
+static void _System threadWrapper(__LIBC_PTHREAD pThrd)
+{
+    int                         tid;
+    EXCEPTIONREGISTRATIONRECORD reg;
+    FS_VAR();
 
-struct _thread *__alloc_thread (void)
-{
-  struct _thread *tp;
-  ULONG rc;
-  FS_VAR();
+    __libc_Back_threadStartup(&reg);
+    pThrd->u.startup.pfnStart(pThrd->u.startup.pvArg);
 
-  FS_SAVE_LOAD();
-  rc = DosAllocMem ((PPVOID)&tp, sizeof (struct _thread),
-                    PAG_COMMIT|PAG_READ|PAG_WRITE);
-  FS_RESTORE();
-  if (rc != 0)
-    return NULL;
-  memset (tp, 0, sizeof (struct _thread));
-  tp->_th_rand = 1;             /* Initialize rand() */
-  return tp;
+    FS_SAVE_LOAD();
+    tid = _gettid();
+    __libc_threadFree(pThrd);
+    __libc_Back_threadEnd(&reg);
+    for (;;)
+        DosExit(tid == 1 ? EXIT_PROCESS : EXIT_THREAD, 0);
 }
 
 
-static void start_thread (struct _thread *tp)
+int _beginthread(void (*pfnStart)(void *), void *pvStack, unsigned cbStack, void *pvArg)
 {
-  EXCEPTIONREGISTRATIONRECORD reg;
+    APIRET          rc;
+    TID             tid;
+    __LIBC_PTHREAD  pThrd;
+    FS_VAR();
 
-  __initthread (&reg);
-  tp->_th_start (tp->_th_arg);
-  _endthread();
+    /*
+     * Allocate a thread structure.
+     */
+    pThrd = __libc_threadAlloc();
+    if (!pThrd)
+    {
+        errno = ENOMEM;
+        return -1;
+    }
+
+    /*
+     * Set the startup thread info and create a new thread.
+     */
+    pThrd->u.startup.pfnStart = pfnStart;
+    pThrd->u.startup.pvArg    = pvArg;
+    FS_SAVE_LOAD();
+    rc = DosCreateThread(&tid,
+                         (PFNTHREAD)threadWrapper,
+                         (ULONG)pThrd,
+                         CREATE_READY | STACK_COMMITTED,
+                         cbStack);
+    FS_RESTORE();
+    if (!rc)
+        return tid;
+
+    /*
+     * Set errno and cleanup.
+     */
+    if (rc == ERROR_NOT_ENOUGH_MEMORY)
+        errno = ENOMEM;
+    else if (rc == ERROR_MAX_THRDS_REACHED)
+        errno = EAGAIN;
+    else
+        errno = EINVAL;
+    __libc_threadFree(pThrd);
+    return -1;
 }
 
 
-int _beginthread (void (*start)(void *arg), void *stack, unsigned stack_size,
-                  void *arg_list)
+void _endthread(void)
 {
-  ULONG rc;
-  TID tid;
-  struct _thread *tp;
-  FS_VAR();
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
+    int             tid;
+    FS_VAR();
 
-  tp = __alloc_thread ();
-  if (tp == NULL)
-    {
-      errno = ENOMEM;
-      return -1;
-    }
-  tp->_th_start = start;
-  tp->_th_arg = arg_list;
-  FS_SAVE_LOAD();
-  rc = DosCreateThread (&tid, (PFNTHREAD)start_thread, (ULONG)tp,
-                        CREATE_SUSPENDED | STACK_COMMITTED, stack_size);
-  if (rc != 0)
-    {
-      if (rc == ERROR_NOT_ENOUGH_MEMORY)
-        errno = ENOMEM;
-      else if (rc == ERROR_MAX_THRDS_REACHED)
-        errno = EAGAIN;
-      else
-        errno = EINVAL;
-      DosFreeMem (tp);
-      FS_RESTORE();
-      return -1;
-    }
-  if (tid > MAX_THREADS)
-    {
-      DosKillThread (tid);
-      errno = EAGAIN;
-      DosFreeMem (tp);
-      FS_RESTORE();
-      return -1;
-    }
-  if (__newthread (tid) != 0)
-    {
-      DosKillThread (tid);
-      DosFreeMem (tp);
-      FS_RESTORE();
-      return -1;
-    }
-  _thread_tab[tid] = tp;
-  rc = DosResumeThread (tid);
-  if (rc != 0)
-    {
-      errno = ESRCH;
-      DosFreeMem (tp);
-      FS_RESTORE();
-      return -1;
-    }
-  FS_RESTORE();
-  return tid;
+    FS_SAVE_LOAD();
+    tid = _gettid();
+    __libc_threadFree(pThrd);
+    for (;;)
+        DosExit(tid == 1 ? EXIT_PROCESS : EXIT_THREAD, 0);
 }
-
-
-void _endthread (void)
-{
-  struct _thread *tp;
-  int tid;
-  FS_VAR();
-
-  tid = _gettid ();
-  tp = _thread ();
-  FS_SAVE_LOAD();
-  if (tp != &thread_1)
-    DosFreeMem (tp);
-  _thread_tab[tid] = NULL;
-  __endthread (tid);
-  for (;;)
-    DosExit ((tid == 1 ? EXIT_PROCESS : EXIT_THREAD), 0);
-}

trunk/src/emx/src/lib/process/threadst.c

@@ -3 +3 @@
 #include "libc-alias.h"
 #include <stdlib.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
+/**
+ * @obsolete
+ */
 void **_threadstore (void)
 {
-  return &_thread()->_th_store;
+  return &__libc_threadCurrent()->pvThreadStoreVar;
 }

trunk/src/emx/src/lib/startup/startup.c

@@ -43 +43 @@
 
 
-/** @page Startup
+/** @page Startup   Startup
  *
  * Quick description of how we startup a process which modules uses LIBC.
@@ -57 +57 @@
  *          - __init_dll initiates _sys_pid and _sys_ppid globals.
  *          - __init_dll creates _sys_heap_fmutex and _sys_gmtxHimem.
- *          - __init_dll then initializes _sys_thread_table and calls __newthread() in
- *            sys/__newthread.c to create the thread 1 entry.
- *              - __newthread() will call __sys_newthread() which inits the high memory
- *                heap (or low if no high mem) when calling _hmalloc().
+ *          - __init_dll then initiates __libc_gpTLS with an allocated TLS ULONG.
+ *            The thread structure it self isn't initialized untill it's actually
+ *            referenced, and when it is there is static structure for the first
+ *            thread needing its per thread area.
  *          - __init_dll calls __init_environ() which initializes environ and _org_environ.
  *              - __init_environ() will call _hmalloc() thus initiating the high heap.

trunk/src/emx/src/lib/str/strerror.c

@@ -5 +5 @@
 #include <stdlib.h>
 #include <string.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include <sys/errno.h>
 
@@ -15 +15 @@
     {
       static char msg[] = "Unknown error ";
-      struct _thread *tp = _thread();
-      memcpy (tp->_th_error, msg, sizeof (msg) - 1);
-      _itoa (errnum, tp->_th_error + sizeof (msg) - 1, 10);
+      __LIBC_PTHREAD pThrd = __libc_threadCurrent();
+      memcpy (pThrd->szStrErrorBuf, msg, sizeof (msg) - 1);
+      _itoa (errnum, pThrd->szStrErrorBuf + sizeof (msg) - 1, 10);
       errno = EINVAL; /* this is actually an invalid error number. */
-      return tp->_th_error;
+      return pThrd->szStrErrorBuf;
     }
 }

trunk/src/emx/src/lib/str/strerror_r.c

@@ -27 +27 @@
 #include <stdlib.h>
 #include <string.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include <sys/errno.h>
 

trunk/src/emx/src/lib/str/strtok.c

@@ -3 +3 @@
 #include "libc-alias.h"
 #include <string.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 char *_STD(strtok) (char *string1, const char *string2)
@@ -9 +9 @@
   char table[256];
   unsigned char *p, *result;
-  struct _thread *tp = _thread ();
+  __LIBC_PTHREAD pThrd = __libc_threadCurrent ();
   if (string1 != NULL)
     p = (unsigned char *)string1;
   else
     {
-      if (tp->_th_strtok_ptr == NULL)
+      if (pThrd->pszStrTokPos == NULL)
         return NULL;
-      p = tp->_th_strtok_ptr;
+      p = pThrd->pszStrTokPos;
     }
   memset (table, 0, 256);
@@ -32 +32 @@
       if (p == result)
         {
-          tp->_th_strtok_ptr = NULL;
+          pThrd->pszStrTokPos = NULL;
           return NULL;
         }
@@ -38 +38 @@
   else
     *p++ = 0;
-  tp->_th_strtok_ptr = p;
+  pThrd->pszStrTokPos = p;
   return (char *)result;
 }

trunk/src/emx/src/lib/sys/__init.c

@@ -25 +25 @@
 #include <emx/umalloc.h>
 #include <alloca.h>
+#include <InnoTekLIBC/thread.h>
 
 
@@ -77 +78 @@
     argc = 0; arg_size = 0;
     /* argv[0] */
-    PUTC(_ARG_NONZERO);
+    PUTC((char)_ARG_NONZERO);
     PUTV;
     for (;;)
@@ -94 +95 @@
             break;
         flag_ptr = pool;
-        PUTC(_ARG_NONZERO);
+        PUTC((char)_ARG_NONZERO);
         PUTV;
         bs = 0; quote = 0;
@@ -226 +227 @@
     _sys_init_ret(pStackFrame);
 
-failure:
+    failure:
     DosExit(EXIT_PROCESS, 255);
 }
@@ -233 +234 @@
 char const _sys_sig_valid[NSIG] =
 {
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1
 };
 
 struct sig_descr const sig_info[NSIG] =
 {
-  {"SIG0",     ST_TERM,   ST_TERM},
-  {"SIGHUP",   ST_TERM,   ST_IGNORE},
-  {"SIGINT",   ST_TERM,   ST_IGNORE},
-  {"SIGQUIT",  ST_TERM,   ST_IGNORE},
-  {"SIGILL",   ST_NEXT,   ST_NEXT},
-  {"SIGTRAP",  ST_NEXT,   ST_NEXT},
-  {"SIGABRT",  ST_TERM,   ST_TERM},
-  {"SIGEMT",   ST_TERM,   ST_TERM},
-  {"SIGFPE",   ST_NEXT,   ST_NEXT},
-  {"SIGKILL",  ST_TERM,   ST_TERM},
-  {"SIGBUS",   ST_TERM,   ST_TERM},
-  {"SIGSEGV",  ST_NEXT,   ST_NEXT},
-  {"SIGSYS",   ST_TERM,   ST_TERM},
-  {"SIGPIPE",  ST_TERM,   ST_IGNORE},
-  {"SIGALRM",  ST_TERM,   ST_IGNORE},
-  {"SIGTERM",  ST_NEXT,   ST_IGNORE},
-  {"SIGUSR1",  ST_IGNORE, ST_IGNORE},
-  {"SIGUSR2",  ST_IGNORE, ST_IGNORE},
-  {"SIGCLD",   ST_IGNORE, ST_IGNORE},
-  {"SIG19",    ST_TERM,   ST_TERM},
-  {"SIG20",    ST_TERM,   ST_TERM},
-  {"SIGBREAK", ST_TERM,   ST_IGNORE}
+    {"SIG0",     ST_TERM,   ST_TERM},
+    {"SIGHUP",   ST_TERM,   ST_IGNORE},
+    {"SIGINT",   ST_TERM,   ST_IGNORE},
+    {"SIGQUIT",  ST_TERM,   ST_IGNORE},
+    {"SIGILL",   ST_NEXT,   ST_NEXT},
+    {"SIGTRAP",  ST_NEXT,   ST_NEXT},
+    {"SIGABRT",  ST_TERM,   ST_TERM},
+    {"SIGEMT",   ST_TERM,   ST_TERM},
+    {"SIGFPE",   ST_NEXT,   ST_NEXT},
+    {"SIGKILL",  ST_TERM,   ST_TERM},
+    {"SIGBUS",   ST_TERM,   ST_TERM},
+    {"SIGSEGV",  ST_NEXT,   ST_NEXT},
+    {"SIGSYS",   ST_TERM,   ST_TERM},
+    {"SIGPIPE",  ST_TERM,   ST_IGNORE},
+    {"SIGALRM",  ST_TERM,   ST_IGNORE},
+    {"SIGTERM",  ST_NEXT,   ST_IGNORE},
+    {"SIGUSR1",  ST_IGNORE, ST_IGNORE},
+    {"SIGUSR2",  ST_IGNORE, ST_IGNORE},
+    {"SIGCLD",   ST_IGNORE, ST_IGNORE},
+    {"SIG19",    ST_TERM,   ST_TERM},
+    {"SIG20",    ST_TERM,   ST_TERM},
+    {"SIGBREAK", ST_TERM,   ST_IGNORE}
 };
 
 
-static void say (const char *msg)
-{
-  __write (2, msg, strlen (msg));
-};
-
-
-static void _sys_terminate (int signo)
-{
-  FS_VAR();
-  PPIB pPib;
-  PTIB pTib;
-  DosGetInfoBlocks (&pTib, &pPib);
-  say ("\r\n");
-  say (pPib->pib_pchcmd);
-  say (":");
-
-  if (signo == SIGABRT)
-    say ("\r\nAbnormal program termination\r\n");
-  else
-    {
-      say ("\r\nProcess terminated by ");
-      say (sig_info[signo].name);
-      say ("\r\n");
-    }
-  FS_SAVE_LOAD();
-  while (1)
-    DosExit (EXIT_PROCESS, 3);
-}
-
-
-static void _sys_signal_acknowledge (int signo)
-{
-  FS_VAR();
-  FS_SAVE_LOAD();
-  switch (signo)
-    {
-    case SIGINT:
-      DosAcknowledgeSignalException (XCPT_SIGNAL_INTR);
-      break;
-    case SIGTERM:
-      DosAcknowledgeSignalException (XCPT_SIGNAL_KILLPROC);
-      break;
-    case SIGBREAK:
-      DosAcknowledgeSignalException (XCPT_SIGNAL_BREAK);
-      break;
-    }
-  FS_RESTORE();
+static void say(const char *msg)
+{
+    __write(2, msg, strlen (msg));
+}
+
+
+static void _sys_terminate(int signo)
+{
+    PPIB    pPib;
+    PTIB    pTib;
+    FS_VAR();
+    DosGetInfoBlocks(&pTib, &pPib);
+    say("\r\n");
+    say(pPib->pib_pchcmd);
+    say(":");
+
+    if (signo == SIGABRT)
+        say("\r\nAbnormal program termination\r\n");
+    else
+    {
+        say("\r\nProcess terminated by ");
+        say(sig_info[signo].name);
+        say("\r\n");
+    }
+    FS_SAVE_LOAD();
+    while (1)
+        DosExit(EXIT_PROCESS, 3);
+}
+
+
+static void _sys_signal_acknowledge(int signo)
+{
+    FS_VAR();
+    FS_SAVE_LOAD();
+    switch (signo)
+    {
+        case SIGINT:
+            DosAcknowledgeSignalException(XCPT_SIGNAL_INTR);
+            break;
+        case SIGTERM:
+            DosAcknowledgeSignalException(XCPT_SIGNAL_KILLPROC);
+            break;
+        case SIGBREAK:
+            DosAcknowledgeSignalException(XCPT_SIGNAL_BREAK);
+            break;
+    }
+    FS_RESTORE();
 }
 
@@ -315 +316 @@
 /* Called from OS/2 exception handler for signal exceptions. */
 
-static ULONG _sys_signal (int signo)
-{
-  thread_data *tp;
-
-  tp = SYS_THREAD;
-  if (tp == NULL)
-    return XCPT_CONTINUE_SEARCH;
-  __sigaddset (&tp->sig_pending, signo);
-  _sys_signal_acknowledge (signo);
-  _sys_deliver_pending_signals (tp);
-  switch (sig_info[signo].fun_action)
-  {
-    case ST_TERM:
-      _sys_terminate (signo);
-    case ST_NEXT:
-      return XCPT_CONTINUE_SEARCH;
-    case ST_IGNORE:
-      return XCPT_CONTINUE_EXECUTION;
-  }
-  return XCPT_CONTINUE_SEARCH;  /* Keep the optimizer happy */
+static ULONG _sys_signal(int signo)
+{
+    __LIBC_PTHREAD pThrd = __libc_threadCurrentNoAuto();
+    if (pThrd == NULL)
+        return XCPT_CONTINUE_SEARCH;
+    __sigaddset (&pThrd->b.sys.sig_pending, signo);
+    _sys_signal_acknowledge(signo);
+    _sys_deliver_pending_signals(pThrd);
+    switch (sig_info[signo].fun_action)
+    {
+        case ST_TERM:
+            _sys_terminate(signo);
+        case ST_NEXT:
+            return XCPT_CONTINUE_SEARCH;
+        case ST_IGNORE:
+            return XCPT_CONTINUE_EXECUTION;
+    }
+    return XCPT_CONTINUE_SEARCH;  /* Keep the optimizer happy */
 }
 
@@ -340 +339 @@
 /* Called from OS/2 exception handler for traps. */
 
-static ULONG _sys_trap (int signo)
-{
-  thread_data *tp;
-  void (*handler)(int signo);
-
-  tp = SYS_THREAD;
-  if (tp == NULL)
-    return XCPT_CONTINUE_SEARCH;
-  handler = tp->signals[signo].sa_handler;
-  if (handler != SIG_IGN && handler != SIG_DFL)
-    handler (signo);
-  switch (sig_info[signo].fun_action)
-    {
-    case ST_TERM:
-      _sys_terminate (signo);
-    case ST_NEXT:
-      return XCPT_CONTINUE_SEARCH;
-    case ST_IGNORE:
-      return XCPT_CONTINUE_EXECUTION;
-    }
-  return XCPT_CONTINUE_SEARCH;  /* Keep the optimizer happy */
-}
-
-
-static void _sys_deliver_signal (thread_data *tp, int signo)
-{
-  struct sigaction *p;
-  void (*handler)(int signo);
-  sigset_t mask, old_blocked;
-
-  /* TODO: Critical section */
-
-  mask = _SIGMASK (signo);
-  p = &tp->signals[signo];
-
-  tp->sig_pending &= ~mask;
-  handler = p->sa_handler;
-
-  if (handler == SIG_IGN)
-    {
-      /* Ignore the signal. */
-    }
-  else if (handler == SIG_DFL)
-    {
-      if (sig_info[signo].dfl_action != ST_IGNORE)
-        _sys_terminate (signo);
-    }
-  else
-    {
-      if (p->sa_flags & SA_SYSV)
+static ULONG _sys_trap(int signo)
+{
+    __LIBC_PTHREAD  pThrd;
+    void          (*handler)(int signo);
+
+    pThrd = __libc_threadCurrentNoAuto();
+    if (pThrd == NULL)
+        return XCPT_CONTINUE_SEARCH;
+    handler = pThrd->b.sys.signals[signo].sa_handler;
+    if (handler != SIG_IGN && handler != SIG_DFL)
+        handler(signo);
+    switch (sig_info[signo].fun_action)
+    {
+        case ST_TERM:
+            _sys_terminate(signo);
+        case ST_NEXT:
+            return XCPT_CONTINUE_SEARCH;
+        case ST_IGNORE:
+            return XCPT_CONTINUE_EXECUTION;
+    }
+    return XCPT_CONTINUE_SEARCH;  /* Keep the optimizer happy */
+}
+
+
+static void _sys_deliver_signal(__LIBC_PTHREAD pThrd, int signo)
+{
+    struct sigaction *p;
+    void (*handler)(int signo);
+    sigset_t mask, old_blocked;
+
+    /* TODO: Critical section */
+
+    mask = _SIGMASK(signo);
+    p = &pThrd->b.sys.signals[signo];
+
+    pThrd->b.sys.sig_pending &= ~mask;
+    handler = p->sa_handler;
+
+    if (handler == SIG_IGN)
+    {
+        /* Ignore the signal. */
+    }
+    else if (handler == SIG_DFL)
+    {
+        if (sig_info[signo].dfl_action != ST_IGNORE)
+            _sys_terminate(signo);
+    }
+    else
+    {
+        if (p->sa_flags & SA_SYSV)
         {
-          p->sa_handler = SIG_DFL;
-          handler (signo);
+            p->sa_handler = SIG_DFL;
+            handler(signo);
         }
-      else if (p->sa_flags & SA_ACK)
+        else if (p->sa_flags & SA_ACK)
         {
-          tp->sig_blocked |= mask;
-          handler (signo);
+            pThrd->b.sys.sig_blocked |= mask;
+            handler(signo);
         }
-      else
+        else
         {
-          old_blocked = tp->sig_blocked;
-          SET_BLOCKED (tp, tp->sig_blocked | mask | p->sa_mask);
-          handler (signo);
-          tp->sig_blocked = old_blocked;
+            old_blocked = pThrd->b.sys.sig_blocked;
+            SET_BLOCKED(&pThrd->b.sys, pThrd->b.sys.sig_blocked | mask | p->sa_mask);
+            handler(signo);
+            pThrd->b.sys.sig_blocked = old_blocked;
         }
     }
@@ -410 +409 @@
 
 
-void _sys_deliver_pending_signals (thread_data *tp)
-{
-  int signo;
-
-  /* TODO: Critical section */
-  while ((tp->sig_pending & ~tp->sig_blocked) != 0)
-    {
-      for (signo = 1; signo < NSIG; ++signo)
-        if (tp->sig_pending & ~tp->sig_blocked & _SIGMASK (signo))
-          _sys_deliver_signal (tp, signo);
+void _sys_deliver_pending_signals(__LIBC_PTHREAD pThrd)
+{
+    int signo;
+
+    /* TODO: Critical section */
+    while ((pThrd->b.sys.sig_pending & ~pThrd->b.sys.sig_blocked) != 0)
+    {
+        for (signo = 1; signo < NSIG; ++signo)
+            if (pThrd->b.sys.sig_pending & ~pThrd->b.sys.sig_blocked & _SIGMASK(signo))
+                _sys_deliver_signal(pThrd, signo);
     }
 }
 
 /* from kLib/kHeapDbg.h */
-typedef enum { enmRead, enmWrite, enmUnknown } ENMACCESS;
+typedef enum
+{
+    enmRead, enmWrite, enmUnknown
+} ENMACCESS;
 extern BOOL _Optlink kHeapDbgException(void *    pvAccess,
                                        ENMACCESS enmAccess,
@@ -432 +434 @@
 asm (".weak kHeapDbgException");
 
-ULONG _sys_exception (PEXCEPTIONREPORTRECORD report,
-                      PEXCEPTIONREGISTRATIONRECORD registration,
-                      PCONTEXTRECORD context,
-                      PVOID whatever)
-{
-  __asm__ ("cld");              /* Don't trust */
-  if (report->fHandlerFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
+ULONG _System _sys_exception(PEXCEPTIONREPORTRECORD report,
+                             PEXCEPTIONREGISTRATIONRECORD registration,
+                             PCONTEXTRECORD context,
+                             PVOID whatever)
+{
+    __asm__ ("cld");              /* Don't trust */
+    if (report->fHandlerFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
+        return XCPT_CONTINUE_SEARCH;
+    switch (report->ExceptionNum)
+    {
+        case XCPT_SIGNAL:
+            if (report->cParameters >= 1)
+            {
+                if (report->ExceptionInfo[0] == XCPT_SIGNAL_INTR)
+                    return _sys_signal(SIGINT);
+                else if (report->ExceptionInfo[0] == XCPT_SIGNAL_KILLPROC)
+                    return _sys_signal(SIGTERM);
+                else if (report->ExceptionInfo[0] == XCPT_SIGNAL_BREAK)
+                    return _sys_signal(SIGBREAK);
+            }
+            break;
+        case XCPT_ACCESS_VIOLATION:
+            /* If we're linking libc01.elh or someone is linking static libc
+               together with kLib the electric fence heap will get the opportunity
+               to check if any access violation was caused by someone touching any
+               of the electric fences. */
+            if (    kHeapDbgException
+                &&  (   report->ExceptionInfo[0] == XCPT_READ_ACCESS
+                        || report->ExceptionInfo[0] == XCPT_WRITE_ACCESS
+                        || report->ExceptionInfo[0] == XCPT_EXECUTE_ACCESS
+                        || report->ExceptionInfo[0] == XCPT_UNKNOWN_ACCESS)
+               )
+            {
+                ENMACCESS enmAccess = enmRead;
+                switch (report->ExceptionInfo[0])
+                {
+                    case XCPT_WRITE_ACCESS:     enmAccess = enmWrite; break;
+                    case XCPT_UNKNOWN_ACCESS:   enmAccess = enmUnknown; break;
+                }
+                /* This call returns true if the page was commited in order
+                   to workaround the immediate problem. If it returns false
+                   the default action should be taken. */
+                if (kHeapDbgException((void*)report->ExceptionInfo[1],
+                                      enmAccess,
+                                      report->ExceptionAddress,
+                                      report))
+                    return XCPT_CONTINUE_EXECUTION;
+            }
+        case XCPT_DATATYPE_MISALIGNMENT:
+            return _sys_trap(SIGSEGV);
+
+        case XCPT_INTEGER_DIVIDE_BY_ZERO:
+        case XCPT_INTEGER_OVERFLOW:
+        case XCPT_ARRAY_BOUNDS_EXCEEDED:
+        case XCPT_FLOAT_DENORMAL_OPERAND:
+        case XCPT_FLOAT_DIVIDE_BY_ZERO:
+        case XCPT_FLOAT_INEXACT_RESULT:
+        case XCPT_FLOAT_INVALID_OPERATION:
+        case XCPT_FLOAT_OVERFLOW:
+        case XCPT_FLOAT_STACK_CHECK:
+        case XCPT_FLOAT_UNDERFLOW:
+            return _sys_trap(SIGFPE);
+
+        case XCPT_ILLEGAL_INSTRUCTION:
+        case XCPT_INVALID_LOCK_SEQUENCE:
+        case XCPT_PRIVILEGED_INSTRUCTION:
+            return _sys_trap(SIGILL);
+    }
     return XCPT_CONTINUE_SEARCH;
-  switch (report->ExceptionNum)
-    {
-    case XCPT_SIGNAL:
-      if (report->cParameters >= 1)
-        {
-          if (report->ExceptionInfo[0] == XCPT_SIGNAL_INTR)
-            return _sys_signal (SIGINT);
-          else if (report->ExceptionInfo[0] == XCPT_SIGNAL_KILLPROC)
-            return _sys_signal (SIGTERM);
-          else if (report->ExceptionInfo[0] == XCPT_SIGNAL_BREAK)
-            return _sys_signal (SIGBREAK);
-        }
-      break;
-    case XCPT_ACCESS_VIOLATION:
-      /* If we're linking libc01.elh or someone is linking static libc
-         together with kLib the electric fence heap will get the opportunity
-         to check if any access violation was caused by someone touching any
-         of the electric fences. */
-      if (    kHeapDbgException
-          &&  (   report->ExceptionInfo[0] == XCPT_READ_ACCESS
-               || report->ExceptionInfo[0] == XCPT_WRITE_ACCESS
-               || report->ExceptionInfo[0] == XCPT_EXECUTE_ACCESS
-               || report->ExceptionInfo[0] == XCPT_UNKNOWN_ACCESS)
-          )
-        {
-          ENMACCESS enmAccess = enmRead;
-          switch (report->ExceptionInfo[0])
-          {
-            case XCPT_WRITE_ACCESS:     enmAccess = enmWrite; break;
-            case XCPT_UNKNOWN_ACCESS:   enmAccess = enmUnknown; break;
-          }
-          /* This call returns true if the page was commited in order
-             to workaround the immediate problem. If it returns false
-             the default action should be taken. */
-          if (kHeapDbgException((void*)report->ExceptionInfo[1],
-                                enmAccess,
-                                report->ExceptionAddress,
-                                report))
-                  return XCPT_CONTINUE_EXECUTION;
-        }
-    case XCPT_DATATYPE_MISALIGNMENT:
-      return _sys_trap (SIGSEGV);
-
-    case XCPT_INTEGER_DIVIDE_BY_ZERO:
-    case XCPT_INTEGER_OVERFLOW:
-    case XCPT_ARRAY_BOUNDS_EXCEEDED:
-    case XCPT_FLOAT_DENORMAL_OPERAND:
-    case XCPT_FLOAT_DIVIDE_BY_ZERO:
-    case XCPT_FLOAT_INEXACT_RESULT:
-    case XCPT_FLOAT_INVALID_OPERATION:
-    case XCPT_FLOAT_OVERFLOW:
-    case XCPT_FLOAT_STACK_CHECK:
-    case XCPT_FLOAT_UNDERFLOW:
-      return _sys_trap (SIGFPE);
-
-    case XCPT_ILLEGAL_INSTRUCTION:
-    case XCPT_INVALID_LOCK_SEQUENCE:
-    case XCPT_PRIVILEGED_INSTRUCTION:
-      return _sys_trap (SIGILL);
-    }
-  return XCPT_CONTINUE_SEARCH;
-}
-
-
-void _sys_get_clock (unsigned long *ms)
-{
-  ULONG val_ms;
-  FS_VAR();
-
-  FS_SAVE_LOAD();
-  DosQuerySysInfo (QSV_MS_COUNT, QSV_MS_COUNT, &val_ms, sizeof (val_ms));
-  FS_RESTORE();
-  *ms = val_ms;
-}
-
-
-void _sys_init_thread (thread_data *tp)
-{
-  int n;
-
-  __sigemptyset (&tp->sig_blocked);
-  __sigemptyset (&tp->sig_pending);
-  for (n = 0; n < NSIG; ++n)
-    {
-      tp->signals[n].sa_handler = SIG_DFL;
-      tp->signals[n].sa_flags   = SA_ACK;
-      __sigemptyset (&tp->signals[n].sa_mask);
-    }
-  tp->fd.hdir = HDIR_CREATE;
-  tp->fd.cFiles = 0;
-}
+}
+
+
+void _sys_get_clock(unsigned long *ms)
+{
+    ULONG val_ms;
+    FS_VAR();
+
+    FS_SAVE_LOAD();
+    DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &val_ms, sizeof (val_ms));
+    FS_RESTORE();
+    *ms = val_ms;
+}
+
+

trunk/src/emx/src/lib/sys/__initdll.c

@@ -11 +11 @@
 */
 
-
-/*******************************************************************************
-*   Defined Constants And Macros                                               *
-*******************************************************************************/
-#define SYS_PRIVATE_HEAP_SIZE 0x100000
 
 /*******************************************************************************
@@ -35 +30 @@
 #include <emx/umalloc.h>
 #include <alloca.h>
-
 #include "syscalls.h"
+#include <InnoTekLIBC/thread.h>
 
 /* Make this function an weak external. */
@@ -45 +40 @@
 *   Global Variables                                                           *
 *******************************************************************************/
+__LIBC_PPTHREAD     __libc_gpTLS;
+
 extern unsigned char _osminor;
 extern unsigned char _osmajor;
@@ -59 +56 @@
     PTIB    ptib;
     PPIB    ppib;
-    int     n;
     static int initialized = 0;
 
@@ -110 +106 @@
 
     /*
-     * Initialize thread table and entry for this thread.
+     * Initialize TLS.
      */
-    /** @todo Remove this table, replace it with a pointer backed by TLS memory. */
-    for (n = 0; n < MAX_THREADS; ++n)
-        _sys_thread_table[n] = NULL;
-    __newthread(ptib->tib_ptib2->tib2_ultid);
+    if (!__libc_gpTLS)                  /* !paranoia! */
+    {
+        rc = DosAllocThreadLocalMemory(1, (PULONG*)&__libc_gpTLS);
+        if (rc)
+            return -1;
+    }
 
     /*

trunk/src/emx/src/lib/sys/filefind.c

@@ -12 +12 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+#include <InnoTekLIBC/thread.h>
 
 /**
@@ -114 +115 @@
 {
     ULONG               rc;
-    struct find_data   *pFD = &SYS_THREAD->fd;
+    struct find_data   *pFD = &__libc_threadCurrent()->b.sys.fd;
     FS_VAR();
 
@@ -145 +146 @@
     FS_SAVE_LOAD();
     memset(&pFD->achBuffer[0], 0, sizeof(pFD->achBuffer));
-    rc = DosFindFirst(pszName,
+    rc = DosFindFirst((PCSZ)pszName,
                       &pFD->hdir,
                       attr & (FILE_NORMAL | FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY | FILE_ARCHIVED),
@@ -181 +182 @@
 {
     ULONG               rc;
-    struct find_data   *pFD = &SYS_THREAD->fd;
+    struct find_data   *pFD = &__libc_threadCurrent()->b.sys.fd;
     FS_VAR();
 

trunk/src/emx/src/lib/sys/raise.c

@@ -7 +7 @@
 #include <errno.h>
 #include <emx/syscalls.h>
+#include <InnoTekLIBC/thread.h>
 #include "syscalls.h"
 
-int _STD(raise) (int signo)
+int _STD(raise)(int signo)
 {
-  thread_data *tp;
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
 
-  if (signo < 1 || signo >= NSIG || !_sys_sig_valid[signo])
+    if (signo < 1 || signo >= NSIG || !_sys_sig_valid[signo])
     {
-      errno = EINVAL;
-      return -1;
+        errno = EINVAL;
+        return -1;
     }
-  tp = SYS_THREAD;
-  if (tp == NULL)
+    if (pThrd->b.sys.signals[signo].sa_handler != SIG_IGN)
     {
-      errno = EINVAL;
-      return -1;
+        __sigaddset(&pThrd->b.sys.sig_pending, signo);
+        _sys_deliver_pending_signals(pThrd);
     }
-  if (tp->signals[signo].sa_handler != SIG_IGN)
-    {
-      __sigaddset (&tp->sig_pending, signo);
-      _sys_deliver_pending_signals (tp);
-    }
-  return 0;
+    return 0;
 }

trunk/src/emx/src/lib/sys/sigaction.c

@@ -6 +6 @@
 #include <errno.h>
 #include <emx/syscalls.h>
+#include <InnoTekLIBC/thread.h>
 #include "syscalls.h"
 
-int _STD(sigaction) (int signo, const struct sigaction *iact,
-  struct sigaction *oact)
+int _STD(sigaction)(int signo, const struct sigaction *iact,
+                    struct sigaction *oact)
 {
-  struct sigaction output, *s;
-  thread_data *tp;
+    struct sigaction    output;
+    struct sigaction   *s;
+    __LIBC_PTHREAD      pThrd;
 
-  if (signo < 1 || signo >= NSIG || signo == SIGKILL || !_sys_sig_valid[signo])
+    if (signo < 1 || signo >= NSIG || signo == SIGKILL || !_sys_sig_valid[signo])
     {
-      errno = EINVAL;
-      return -1;
+        errno = EINVAL;
+        return -1;
     }
-  if (signo == SIGKILL && iact != NULL)
+    if (signo == SIGKILL && iact != NULL)
     {
-      errno = EINVAL;
-      return -1;
+        errno = EINVAL;
+        return -1;
     }
-  tp = SYS_THREAD;
-  if (tp == NULL)
+    pThrd = __libc_threadCurrent();
+    s = &pThrd->b.sys.signals[signo];
+    output = *s;
+    if (iact != NULL)
     {
-      errno = EINVAL;
-      return -1;
-    }
-  s = &tp->signals[signo];
-  output = *s;
-  if (iact != NULL)
-    {
-      *s = *iact;
-      if ((s->sa_handler == SIG_DFL
-           && sig_info[signo].dfl_action != ST_IGNORE)
-          || s->sa_handler == SIG_IGN)
-        sigdelset (&tp->sig_pending, signo);
+        *s = *iact;
+        if (    (   s->sa_handler == SIG_DFL
+                 && sig_info[signo].dfl_action != ST_IGNORE)
+            ||  s->sa_handler == SIG_IGN)
+            sigdelset(&pThrd->b.sys.sig_pending, signo);
     }
 
-  if (oact != NULL)
-    *oact = output;
-  return 0;
+    if (oact != NULL)
+        *oact = output;
+    return 0;
 }

trunk/src/emx/src/lib/sys/signal.c

@@ -7 +7 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+#include <InnoTekLIBC/thread.h>
 
-typedef void sigfun (int sig);
+typedef void sigfun(int sig);
 
-sigfun *_STD(signal) (int sig, sigfun *handler)
+sigfun *_STD(signal)(int sig, sigfun *handler)
 {
-  if (handler == SIG_ACK)
+    if (handler == SIG_ACK)
     {
-      thread_data *tp;
+        __LIBC_PTHREAD pThrd;
 
-      if (sig < 1 || sig >= NSIG || sig == SIGKILL || !_sys_sig_valid[sig])
+        if (sig < 1 || sig >= NSIG || sig == SIGKILL || !_sys_sig_valid[sig])
         {
-          errno = EINVAL;
-          return SIG_ERR;
+            errno = EINVAL;
+            return SIG_ERR;
         }
-      tp = SYS_THREAD;
-      if (tp == NULL)
-        return SIG_ERR;
-      sigdelset (&tp->sig_blocked, sig);
-      _sys_deliver_pending_signals (tp);
-      return tp->signals[sig].sa_handler;
+        pThrd = __libc_threadCurrent();
+        if (pThrd == NULL)
+            return SIG_ERR;
+        sigdelset(&pThrd->b.sys.sig_blocked, sig);
+        _sys_deliver_pending_signals(pThrd);
+        return pThrd->b.sys.signals[sig].sa_handler;
     }
-  else
+    else
     {
-      struct sigaction isa, osa;
+        struct sigaction isa, osa;
 
-      isa.sa_handler = handler;
-      isa.sa_mask = 0;
-      isa.sa_flags = SA_ACK;
-      if (sigaction (sig, &isa, &osa) != 0)
-        return SIG_ERR;
-      else
-        return osa.sa_handler;
+        isa.sa_handler = handler;
+        isa.sa_mask = 0;
+        isa.sa_flags = SA_ACK;
+        if (sigaction(sig, &isa, &osa) != 0)
+            return SIG_ERR;
+        else
+            return osa.sa_handler;
     }
 }

trunk/src/emx/src/lib/sys/sigpending.c

@@ -6 +6 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+#include <InnoTekLIBC/thread.h>
 
 int _STD(sigpending) (sigset_t *set)
 {
-  thread_data *tp;
-
-  /* TODO: Critical section */
-  tp = SYS_THREAD;
-  *set = tp->sig_blocked & tp->sig_pending;
-  return 0;
+    /* TODO: Critical section */
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
+    *set = pThrd->b.sys.sig_blocked & pThrd->b.sys.sig_pending;
+    return 0;
 }

trunk/src/emx/src/lib/sys/sigprocmask.c

@@ -7 +7 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+#include <InnoTekLIBC/thread.h>
 
-int _STD(sigprocmask) (int how, const sigset_t *iset, sigset_t *oset)
+int _STD(sigprocmask)(int how, const sigset_t *iset, sigset_t *oset)
 {
-  thread_data *tp;
-  sigset_t temp, output;
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
+    sigset_t temp, output;
 
-  tp = SYS_THREAD;
-  output = tp->sig_blocked;
-  if (iset != NULL)
+    output = pThrd->b.sys.sig_blocked;
+    if (iset != NULL)
     {
-      switch (how)
+        switch (how)
         {
-        case SIG_BLOCK:
-          temp = tp->sig_blocked | *iset;
-          break;
-        case SIG_UNBLOCK:
-          temp = tp->sig_blocked & ~*iset;
-          break;
-        case SIG_SETMASK:
-          temp = *iset;
-          break;
-        default:
-          errno = EINVAL;
-          return -1;
+            case SIG_BLOCK:
+                temp = pThrd->b.sys.sig_blocked | *iset;
+                break;
+            case SIG_UNBLOCK:
+                temp = pThrd->b.sys.sig_blocked & ~*iset;
+                break;
+            case SIG_SETMASK:
+                temp = *iset;
+                break;
+            default:
+                errno = EINVAL;
+                return -1;
         }
-      SET_BLOCKED (tp, temp);
+        SET_BLOCKED(&pThrd->b.sys, temp);
     }
 
-  if (oset != NULL)
-    *oset = output;
+    if (oset != NULL)
+        *oset = output;
 
-  _sys_deliver_pending_signals (tp);
-  return 0;
+    _sys_deliver_pending_signals(pThrd);
+    return 0;
 }

trunk/src/emx/src/lib/sys/sigsuspend.c

@@ -7 +7 @@
 #include <emx/syscalls.h>
 #include "syscalls.h"
+#include <InnoTekLIBC/thread.h>
 
 int _STD(sigsuspend) (const sigset_t *mask)
 {
-  sigset_t old_blocked;
-  thread_data *tp;
+    /* TODO: Critical section */
+    __LIBC_PTHREAD  pThrd = __libc_threadCurrent();
+    sigset_t        old_blocked;
 
-  /* TODO: Critical section */
-  tp = SYS_THREAD;
-  old_blocked = tp->sig_blocked;
-  SET_BLOCKED (tp, *mask);
-  pause ();
-  tp->sig_blocked = old_blocked;
-  errno = EINTR;
-  return -1;
+    old_blocked = pThrd->b.sys.sig_blocked;
+    SET_BLOCKED(&pThrd->b.sys, *mask);
+    pause();
+    pThrd->b.sys.sig_blocked = old_blocked;
+    errno = EINTR;
+    return -1;
 }

trunk/src/emx/src/lib/sys/syscalls.h

@@ -6 +6 @@
 #include "libc-alias.h"
 #include <sys/signal.h>
+
+#ifndef __LIBC_THREAD_DECLARED
+#define __LIBC_THREAD_DECLARED
+struct __libc_threadCurrentSlow;
+typedef struct __libc_threadCurrentSlow *__LIBC_PTHREAD, **__LIBC_PPTHREAD;
+#endif
 
 #if !defined (NULL)
@@ -102 +108 @@
 #define FDATEZEROP(x) (*(PUSHORT)&(x) == 0)
 
-/** Directory find data entry.
- * Used by __findfirst() and __findnext(). */
-struct find_data
-{
-    /** Directory handle. HDIR_CREATE if no session opened. */
-    HDIR        hdir;
-    /** Type of buffer content. FIL_STANDARDL or FIL_STANDARD,
-     * i.e. FILEFINDBUF3 or FILEFINDBUF3L. */
-    ULONG       fType;
-    /** Number of files left in the buffer. */
-    ULONG       cFiles;
-    /** Pointer to the next entry. Don't test on this, test on cFiles! */
-    const char *pchNext;
-    /** Buffer. */
-    char        achBuffer[2048];
-};
-
-typedef struct
-{
-  struct find_data fd;
-  sigset_t sig_blocked;
-  sigset_t sig_pending;
-  struct sigaction signals[NSIG];
-} thread_data;
-
 #if defined (INCL_DOSEXCEPTIONS)
 EXTERN PEXCEPTIONREGISTRATIONRECORD _sys_xreg INIT (NULL);
-ULONG _sys_exception (PEXCEPTIONREPORTRECORD report,
+ULONG _System _sys_exception (PEXCEPTIONREPORTRECORD report,
     PEXCEPTIONREGISTRATIONRECORD registration, PCONTEXTRECORD context,
     PVOID whatever);
@@ -154 +135 @@
 extern struct sig_descr const sig_info[NSIG];
 
-long _sys_p2t (FTIME t, FDATE d);
-void _sys_init_thread (thread_data *tp);
-void _sys_deliver_pending_signals (thread_data *tp);
-
-#define MAX_THREADS 1024
-
-EXTERN thread_data *_sys_thread_table[MAX_THREADS];
-
-thread_data *_sys_thread (void);
-#define SYS_THREAD (_sys_thread ())
+long _sys_p2t(FTIME t, FDATE d);
+void _sys_deliver_pending_signals(__LIBC_PTHREAD pThrd);
 
 #endif /* _OS2EMX_H */

trunk/src/emx/src/lib/time/asctime.c

@@ -4 +4 @@
 #include <string.h>
 #include <time.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 
 static char const months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
@@ -13 +13 @@
 char *_STD(asctime) (const struct tm *t)
 {
-  struct _thread *tp = _thread();
-  return asctime_r(t, tp->_th_asctime_buf);
+  __LIBC_PTHREAD pThrd = __libc_threadCurrent();
+  return asctime_r(t, pThrd->szAscTimeAndCTimeBuf);
 }
 

trunk/src/emx/src/lib/time/gmtime.c

@@ -4 +4 @@
 #include <stdlib.h>
 #include <time.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include <emx/time.h>
 
@@ -69 +69 @@
 struct tm *_STD(gmtime)(const time_t *t)
 {
-    struct _thread *tp = _thread ();
-    return gmtime_r (t, &tp->_th_gmtime_buf);
+    __LIBC_PTHREAD pThrd = __libc_threadCurrent ();
+    return gmtime_r (t, &pThrd->GmTimeAndLocalTimeBuf);
 }

trunk/src/emx/src/lib/time/localtim.c

@@ -3 +3 @@
 #include "libc-alias.h"
 #include <time.h>
-#include <emx/thread.h>
+#include <InnoTekLIBC/thread.h>
 #include <emx/time.h>
 
 struct tm *_STD(localtime)(const time_t *t)
 {
-    struct _thread *tp = _thread();
-    return localtime_r(t, &tp->_th_gmtime_buf);
+    __LIBC_PTHREAD pThrd = __libc_threadCurrent();
+    return localtime_r(t, &pThrd->GmTimeAndLocalTimeBuf);
 }
 

trunk/src/emx/testcase/loadthread2.c

@@ -11 +11 @@
     APIRET  rc;
     szObj[0] = '\0';
-    rc = DosLoadModule(szObj, sizeof(szObj), "LIBC05.DLL", &hmod);
+    rc = DosLoadModule(szObj, sizeof(szObj), "LIBC06.DLL", &hmod);
     if (rc)
-        printf("DosLoadModule failed loading LIBC05.DLL. rc=%d szObj=%s\n", rc, szObj);
+        printf("DosLoadModule failed loading LIBC06.DLL. rc=%d szObj=%s\n", rc, szObj);
     else
-        printf("Successfully loaded LIBC05.DLL\n");
+        printf("Successfully loaded LIBC06.DLL\n");
     grc = rc;
 }

trunk/src/emx/version.smak

@@ -4 +4 @@
 VH = 0
 # Middle part of version number
-VM = 5
+VM = 6
 # Low part of version number
 VL = 0