Changeset 7509


Ignore:
Timestamp:
06/27/18 22:57:39 (3 months ago)
Author:
baker
Message:

temporary hack to catch invalid thread IDs on 64-bit systems, correct thr_ret function definitions (to match declarations in ew_threads.h)

Location:
trunk/src/libsrc
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/libsrc/solaris/threads_ew.c

    r1693 r7509  
    1  
    2 /* 
    3  *   THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE 
    4  *   CHECKED IT OUT USING THE COMMAND CHECKOUT. 
    5  * 
    6  *    $Id$ 
    7  * 
    8  *    Revision history: 
    9  *     $Log$ 
    10  *     Revision 1.3  2004/10/19 22:42:00  mark 
    11  *     Removed thread priority functions (not ready for prime time yet...) 
    12  * 
    13  *     Revision 1.2  2004/10/07 21:31:30  mark 
    14  *     Added thread priority functions 
    15  * 
    16  *     Revision 1.1  2000/02/14 18:46:17  lucky 
    17  *     Initial revision 
    18  * 
    19  * 
    20  */ 
    21  
    221 
    232              /*********************************************** 
     
    298               ***********************************************/ 
    309 
     10#include <assert.h>                     /* assert() */ 
     11 
     12#include <signal.h> 
    3113#include <stdio.h> 
     14#include <stdlib.h> 
    3215#include <sys/types.h> 
    3316#include <thread.h> 
    34 #include <signal.h> 
     17 
     18#include "ew_threads.h"                 /* Earthworm threads API */ 
    3519 
    3620void SignalHandle( int ); 
    37  
    3821 
    3922   /******************************************************************** 
     
    5336    ********************************************************************/ 
    5437 
    55 int StartThread( void *fun(void *), unsigned stack_size, unsigned *thread_id ) 
    56 { 
     38int StartThread( thr_ret (*fun)( void * ), 
     39                 unsigned int stack_size, 
     40                 unsigned int *thread_id ) { 
     41 
    5742   int rc;                       /* Function return code */ 
    5843   thread_t tid;                 /* SendMsg thread id */ 
     
    6954      some afterlife, waiting for some other thread to pick up it's exit 
    7055      status before it can truly cease to be...*/ 
    71    rc = thr_create( (void *)0, stackSize, fun, (void *)0, 
     56   rc = thr_create( NULL, stackSize, fun, NULL, 
    7257                    THR_DETACHED|THR_NEW_LWP, &tid ); 
    7358   if ( rc != 0 ) 
    7459      return( -1 ); 
    7560 
    76    *thread_id = (unsigned)tid; 
    77    return( 0 ); 
     61   *thread_id = (unsigned) tid; 
     62 
     63   assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     64 
     65   return 0; 
    7866} 
    79  
    8067 
    8168   /******************************************************************** 
     
    9683    ********************************************************************/ 
    9784 
    98 int StartThreadWithArg( void *fun(void *),void* arg, unsigned stack_size,  
    99                         unsigned *thread_id ) 
    100 { 
     85int StartThreadWithArg( thr_ret (*fun)( void * ), 
     86                        void *arg, 
     87                        unsigned int stack_size, 
     88                        unsigned int *thread_id ) { 
     89 
    10190   int rc;                       /* Function return code */ 
    10291   thread_t tid;                 /* SendMsg thread id */ 
     
    113102      some afterlife, waiting for some other thread to pick up it's exit 
    114103      status before it can truly cease to be...*/ 
    115    rc = thr_create( (void *)0, stackSize, fun, (void *)arg, 
     104   rc = thr_create( NULL, stackSize, fun, (void *) arg, 
    116105                    THR_DETACHED|THR_NEW_LWP, &tid ); 
    117106   if ( rc != 0 ) 
    118107      return( -1 ); 
    119108 
    120    *thread_id = (unsigned)tid; 
    121    return( 0 ); 
     109   *thread_id = (unsigned) tid; 
     110 
     111   assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     112 
     113   return 0; 
    122114} 
    123  
    124115 
    125116  /************************************************************* 
     
    133124   *************************************************************/ 
    134125 
    135 void WaitThread( unsigned *thread_id ) 
    136 { 
     126int WaitThread( unsigned int *thread_id ) { 
     127   return 0; 
    137128} 
    138  
    139129 
    140130   /************************************************************* 
     
    150140    *************************************************************/ 
    151141 
    152 int KillThread( unsigned int tid ) 
    153 { 
     142int KillThread( unsigned int tid ) { 
    154143   return( thr_kill( (thread_t) tid, SIGUSR1 ) ); 
    155144} 
    156  
    157  
    158145 
    159146   /*************************************************************** 
     
    166153    ***************************************************************/ 
    167154 
    168 int KillSelfThread( ) 
    169 { 
     155int KillSelfThread( void ) { 
    170156   thr_exit( (void *)NULL ); 
    171157   return 0;                     /* well, not really */ 
    172158} 
    173  
    174159 
    175160   /************************************************************* 
     
    180165    *************************************************************/ 
    181166 
    182 void SignalHandle( int sig ) 
    183 { 
     167void SignalHandle( int sig ) { 
     168 
    184169   void *status; 
    185170  
    186    switch (sig) 
    187    { 
     171   switch (sig) { 
     172 
    188173   case SIGUSR1: 
    189174        /*printf( "thread:%d caught SIGUSR1; calling thr_exit()\n", 
     
    192177   } 
    193178} 
    194      
  • trunk/src/libsrc/unix/threads_ew.c

    r5825 r7509  
    1 #define _XOPEN_SOURCE 500 
    2  
    31              /*********************************************** 
    42               *                threads_ew.c                 * 
     
    97               ***********************************************/ 
    108 
     9#define _XOPEN_SOURCE 500 
     10 
     11#include <assert.h>                     /* assert() */ 
     12 
     13#include <signal.h> 
    1114#include <stdio.h> 
     15#include <stdlib.h> 
     16#include <string.h> 
    1217#include <sys/types.h> 
    13 #include <errno.h> 
    14 #include <string.h> 
    15 #include <signal.h> 
    16 #ifdef _USE_PTHREADS 
    17 #include <unistd.h> 
     18#ifdef _USE_PTHREADS 
    1819#include <pthread.h> 
    1920#include <sys/param.h> 
     21#include <unistd.h> 
    2022#else /* Solaris threads */ 
    2123# include <thread.h> 
     
    2628#endif 
    2729 
     30#include "ew_threads.h"                 /* Earthworm threads API */ 
     31 
    2832#ifdef _USE_POSIX_SIGNALS 
    2933void SignalHandle(int, siginfo_t *, void *); 
     
    3337 
    3438#ifdef _USE_PTHREADS 
    35 int setStackSize(char *function_text, pthread_attr_t *pattr, int stack_size); 
     39static int setStackSize( char *, pthread_attr_t *, unsigned int ); 
    3640#endif 
    3741 
     
    5256    ********************************************************************/ 
    5357 
    54 int StartThread( void *fun(void *), unsigned stack_size, unsigned *thread_id ) 
    55 { 
     58int StartThread( thr_ret (*fun)( void * ), 
     59                 unsigned int stack_size, 
     60                 unsigned int *thread_id ) { 
     61 
    5662   int error;                     /* Function return code */ 
    5763   pthread_t tid;                 /* SendMsg thread id */ 
     
    95101        return (-1); 
    96102   } 
    97    if ( (error = pthread_create( &tid, &attr, fun, (void *)NULL )) != 0 ) { 
     103   if ( (error = pthread_create( &tid, &attr, fun, NULL )) != 0 ) { 
    98104      fprintf(stderr,"StartThread: pthread_create error: %s\n",strerror(error)); 
    99105      return( -1 ); 
     
    115121      some afterlife, waiting for some other thread to pick up it's exit 
    116122      status before it can truly cease to be...*/ 
    117    error = thr_create( (void *)0, stackSize, fun, (void *)0, 
     123   error = thr_create( NULL, stackSize, fun, NULL, 
    118124                    THR_DETACHED|THR_NEW_LWP, &tid ); 
    119125   if ( error != 0 ) { 
     
    123129#endif 
    124130 
    125  
    126  
    127    *thread_id = (unsigned)tid; 
    128    return( 0 ); 
    129 } 
    130  
     131   *thread_id = (unsigned) tid; 
     132 
     133   assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     134 
     135   return 0; 
     136} 
    131137 
    132138   /******************************************************************** 
     
    147153    ********************************************************************/ 
    148154 
    149 int StartThreadWithArg( void *fun(void *),void* arg, unsigned stack_size,  
    150                         unsigned *thread_id ) 
    151 { 
     155int StartThreadWithArg( thr_ret (*fun)( void * ), 
     156                        void *arg, 
     157                        unsigned int stack_size,  
     158                        unsigned int *thread_id ) { 
     159 
    152160   int error;                    /* Function return code */ 
    153161   pthread_t tid;                /* SendMsg thread id */ 
     
    187195        return (-1); 
    188196   } 
    189    if ( (error = pthread_create( &tid, &attr, fun, (void *)arg )) != 0 ) { 
     197   if ( (error = pthread_create( &tid, &attr, fun, (void *) arg )) != 0 ) { 
    190198      fprintf(stderr,"StartThreadWithArg: pthread_create error: %s\n",strerror(error)); 
    191199      return( -1 ); 
     
    207215      some afterlife, waiting for some other thread to pick up it's exit 
    208216      status before it can truly cease to be...*/ 
    209    error = thr_create( (void *)0, stackSize, fun, (void *)arg, 
     217   error = thr_create( NULL, stackSize, fun, (void *) arg, 
    210218                    THR_DETACHED|THR_NEW_LWP, &tid ); 
    211219   if ( error != 0 ) { 
     
    215223#endif 
    216224 
    217    *thread_id = (unsigned)tid; 
    218    return( 0 ); 
    219 } 
    220  
     225   *thread_id = (unsigned) tid; 
     226 
     227   assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     228 
     229   return 0; 
     230} 
    221231 
    222232  /************************************************************* 
     
    230240   *************************************************************/ 
    231241 
    232 void WaitThread( unsigned *thread_id ) 
    233 { 
    234 } 
    235  
     242int WaitThread( unsigned int *thread_id ) { 
     243   return 0; 
     244} 
    236245 
    237246   /************************************************************* 
     
    247256    *************************************************************/ 
    248257 
    249 int KillThread( unsigned int tid ) 
    250 { 
     258int KillThread( unsigned int tid ) { 
    251259   return( pthread_kill( (pthread_t) tid, SIGUSR1 ) ); 
    252260} 
    253  
    254  
    255261 
    256262   /*************************************************************** 
     
    263269    ***************************************************************/ 
    264270 
    265 int KillSelfThread(void) 
    266 { 
    267    pthread_exit((void *)NULL ); 
     271int KillSelfThread( void ) { 
     272   pthread_exit( NULL ); 
    268273   return 0;                     /* well, not really */ 
    269274} 
    270  
    271  
    272275 
    273276   /************************************************************* 
     
    279282 
    280283#ifdef _USE_POSIX_SIGNALS 
    281 void SignalHandle(int sig, siginfo_t *sip, void *up) 
     284void SignalHandle( int sig, siginfo_t *sip, void *up ) 
    282285#else 
    283286void SignalHandle( int sig ) 
     
    297300#ifdef _USE_PTHREADS 
    298301 
    299 int setStackSize(char *function_text, pthread_attr_t *pattr, int stack_size) 
     302static int setStackSize( char *function_text, 
     303                         pthread_attr_t *pattr, 
     304                         unsigned int stack_size) 
    300305{ 
    301306   int error;                     /* Function return code */ 
     
    332337        */ 
    333338   } 
    334    return (0); 
    335 } 
    336  
    337 #endif 
     339   return 0; 
     340} 
     341 
     342#endif 
  • trunk/src/libsrc/winnt/threads_ew.c

    r6803 r7509  
    1  
    2 /* 
    3  *   THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE 
    4  *   CHECKED IT OUT USING THE COMMAND CHECKOUT. 
    5  * 
    6  *    $Id$ 
    7  * 
    8  *    Revision history: 
    9  *     $Log$ 
    10  *     Revision 1.3  2004/10/19 22:42:22  mark 
    11  *     Removed thread priority functions (not ready for prime time yet...) 
    12  * 
    13  *     Revision 1.2  2004/10/07 21:32:15  mark 
    14  *     Added thread priority functions 
    15  * 
    16  *     Revision 1.1  2000/02/14 18:53:30  lucky 
    17  *     Initial revision 
    18  * 
    19  * 
    20  */ 
    211 
    222              /******************************************** 
     
    277              *********************************************/ 
    288 
     9#include <assert.h>                     /* assert() */ 
     10 
    2911#include <windows.h> 
    3012#include <process.h> 
    3113 
     14#include "ew_threads.h"                 /* Earthworm threads API */ 
    3215 
    3316   /******************************************************************** 
     
    5336    ********************************************************************/ 
    5437 
    55 int StartThread( void fun(void *), unsigned stack_size, unsigned *thread_id ) 
    56 { 
     38int StartThread( thr_ret (*fun)( void * ), 
     39                 unsigned int stack_size, 
     40                 unsigned int *thread_id ) { 
     41 
    5742   uintptr_t tid; 
    5843 
     
    6247      return -1; 
    6348 
    64    *thread_id = (unsigned)tid;     /* Return the thread id */ 
     49   *thread_id = (unsigned) tid;         /* Return the thread id */ 
     50 
     51   assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     52 
    6553   return 0; 
    6654} 
     
    8775    ********************************************************************/ 
    8876 
    89 int StartThreadWithArg( void fun(void *), void* arg, unsigned stack_size,  
    90                         unsigned *thread_id ) 
    91 { 
     77int StartThreadWithArg( thr_ret (*fun)( void * ), 
     78                        void *arg, 
     79                        unsigned int stack_size,  
     80                        unsigned int *thread_id ) { 
     81 
    9282   uintptr_t tid; 
    9383 
     
    9787      return -1; 
    9888 
    99    *thread_id = (unsigned)tid;     /* Return the thread id */ 
     89   *thread_id = (unsigned) tid;         /* Return the thread id */ 
     90 
     91   assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     92 
    10093   return 0; 
    10194} 
    102  
    10395 
    10496   /************************************************************* 
     
    108100    *************************************************************/ 
    109101 
    110 int KillSelfThread( void ) 
    111 { 
     102int KillSelfThread( void ) { 
    112103    _endthread(); 
    113104    return 0; 
    114105} 
    115  
    116106 
    117107  /************************************************************* 
     
    128118   *************************************************************/ 
    129119 
    130 int WaitThread( unsigned *thread_id ) 
    131 { 
     120int WaitThread( unsigned int *thread_id ) { 
    132121   if ( WaitForSingleObject( (HANDLE)(*thread_id), INFINITE ) 
    133122                                             == WAIT_FAILED ) 
     
    135124   return 0; 
    136125} 
    137  
    138126 
    139127   /************************************************************ 
     
    153141    ************************************************************/ 
    154142 
    155 int KillThread( unsigned int tid ) 
    156 { 
     143int KillThread( unsigned int tid ) { 
     144 
    157145    const DWORD exit_code = 0; 
    158146 
     
    162150    return 0; 
    163151} 
    164  
Note: See TracChangeset for help on using the changeset viewer.