static void create_key_once(void) { pthread_key_create(&g_key, NULL); }
Deleter() { pthread_key_create(&pkey_, &ThreadLocalSingleton::destructor); }
static void make_key() { (void) pthread_key_create(&tlsKey, NULL); }
int main (int argc, char *argv[]) { int ret=0; void * rval; pthread_t child; int i,j; output_init(); scenar_init(); for (j=0; j<3; j++) { ret = pthread_key_create(&tld[j], destructor); if (ret != 0) { UNRESOLVED(ret, "Failed to create a TLD key"); } } for (i=0; i < NSCENAR; i++) { if (scenarii[i].detached == 0) { #if VERBOSE > 0 output("-----\n"); output("Starting test with scenario (%i): %s\n", i, scenarii[i].descr); #endif for (j=0; j<4; j++) tab[j]=0; global=0; ret = pthread_create(&child, &scenarii[i].ta, threaded, NULL); switch (scenarii[i].result) { case 0: /* Operation was expected to succeed */ if (ret != 0) { UNRESOLVED(ret, "Failed to create this thread"); } break; case 1: /* Operation was expected to fail */ if (ret == 0) { UNRESOLVED(-1, "An error was expected but the thread creation succeeded"); } break; case 2: /* We did not know the expected result */ default: #if VERBOSE > 0 if (ret == 0) { output("Thread has been created successfully for this scenario\n"); } else { output("Thread creation failed with the error: %s\n", strerror(ret)); } #endif } if (ret == 0) /* The new thread is running */ { ret = pthread_join(child, &rval); if (ret != 0) { UNRESOLVED(ret, "Unable to join a thread"); } if (rval != (NULL+1)) { FAILED("pthread_join() did not retrieve the pthread_exit() param"); } for (j=0; j<3; j++) { if ((tab[j] != j+1) || (tab[3] != 9)) { output("dump:\ntab[0]=%i\ntab[1]=%i\ntab[2]=%i\ntab[3]=%i\n", tab[0], tab[1], tab[2], tab[3]); FAILED("The cleanup handlers were not called as expected"); } } } } } for (j=0; j<3; j++) { ret = pthread_key_delete(tld[j]); if (ret != 0) { UNRESOLVED(ret, "Failed to delete a TLD key"); } } scenar_fini(); #if VERBOSE > 0 output("-----\n"); output("All test data destroyed\n"); output("Test PASSED\n"); #endif PASSED; }
static void icalerrno_key_alloc(void) { pthread_key_create(&icalerrno_key, icalerrno_destroy); }
void l_random_setup(void) { pthread_key_create(&key, l_random_key_destructor); }
static void ecpg_actual_connection_init(void) { pthread_key_create(&actual_connection_key, NULL); }
static __inline void emutls_init(void) { if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0) abort(); emutls_key_created = true; }
ThreadLocal(bool destroy = true) { pthread_key_create(&m_key, destroy ? &ThreadLocal::Destroy : &ThreadLocal::Empty); }
static void thread_init(void) { pthread_key_create(&__ph_thread_key, destroy_thread); ck_epoch_init(&misc_epoch); }
/* * TaskLib init function */ STATUS taskLibInit(void) { OS_TCB *tcb; struct sched_param param; int policy; char name[12]; /* Determine the min and max allowable priorities */ #ifdef PTHREAD_MIN_PRIORITY rr_min_priority = PTHREAD_MIN_PRIORITY; #else rr_min_priority = sched_get_priority_min (SCHED_RR); #endif #ifdef PTHREAD_MAX_PRIORITY rr_max_priority = PTHREAD_MAX_PRIORITY; #else rr_max_priority = sched_get_priority_max (SCHED_RR); #endif /* Create a thread specific key to access TCB */ pthread_key_create(&taskControlBlock, NULL); /* allocate a TCB for main thread */ tcb = (OS_TCB *)malloc(sizeof(OS_TCB)); if (tcb == NULL) { return ERROR; } snprintf(name, sizeof(name), "tUnix%d", (int)getpid()); tcb->name = strdup(name); #ifdef HAVE_PTHREAD_ATTR_SETSCHEDPOLICY pthread_getschedparam(pthread_self(), &policy, ¶m); #else policy = 0; param.sched_priority = rr_min_priority; #endif tcb->policy = policy; tcb->priority = priorityPosixToVx(param.sched_priority); tcb->options = 0; tcb->entry = NULL; /* implicit main() */ tcb->errorStatus = errno; /* Process and thread ids */ tcb->pid = getpid(); tcb->tid = pthread_self(); /* The tcb list is initially empty */ tcb->next = NULL; /* Mark the TCB */ tcb->magic = TASK_MAGIC; /* Register the TCB pointer in the thread-specific key */ #ifdef DEBUG fprintf(stderr, "registering task specific value %lu %lu\n", (unsigned long)tcb, (unsigned long)pthread_self()); #endif if (pthread_setspecific(taskControlBlock, (void *)tcb) != 0) { errnoSet(errno); return ERROR; } /* Initialize the global task List */ taskList = tcb; return OK; }
void initThreadLocal(JNIEnv* env) { pthread_key_create(&gTlsKey, destroyThreadLocal); }
void x_init() { pthread_key_create(&g_except_key, NULL); pthread_key_create(&g_error_key, NULL); }
static void _xc_init_errbuf(void) { pthread_key_create(&errbuf_pkey, _xc_clean_errbuf); }
// NOTE: glibc used uint as pthread_key_t. void tsd_create(uint_t * key, void (*exit)(void *)) { VERIFY0(pthread_key_create(key, exit)); }
ThreadLocal() { pthread_key_create(&m_key, &ThreadLocal::Destroy); }
static void np_init_error_key() { pthread_key_create(&error_key, np_destroy_error); }
int ldap_pvt_thread_key_create( ldap_pvt_thread_key_t *key ) { return pthread_key_create( key, NULL ); }
static void init_errno(void) { pthread_key_create(&errno_key, free); }
/** * Allocates a thread-specific variable. * @param key where to store the thread-specific variable handle * @param destr a destruction callback. It is called whenever a thread exits * and the thread-specific variable has a non-NULL value. * @return 0 on success, a system error code otherwise. This function can * actually fail because there is a fixed limit on the number of * thread-specific variable in a process on most systems. */ int vlc_threadvar_create (vlc_threadvar_t *key, void (*destr) (void *)) { return pthread_key_create (key, destr); }
/* Create Key */ static void fr_strerror_make_key(void) { pthread_key_create(&fr_strerror_key, NULL); }
static void g_uselocale_key_init() { pthread_key_create(&g_uselocale_key, NULL); }
static void thread_init(void) { pthread_key_create(&key, free); }
//static int init_complete; void InitSyslog( int ignore_options ) { #ifndef __STATIC_GLOBALS__ if( syslog_local ) { #ifndef __NO_OPTIONS__ if( !ignore_options ) LoadOptions(); #endif return; } SimpleRegisterAndCreateGlobal( syslog_local ); if( !(*syslog_local).flags.bInitialized ) #endif { //logtype = SYSLOG_FILE; //(*syslog_local).file = stderr; #if defined( WIN32 ) (*syslog_local).next_lprintf_tls = TlsAlloc(); #elif defined( __LINUX__ ) pthread_key_create( &((*syslog_local).next_lprintf_tls), NULL ); #endif (*syslog_local).flags.bLogThreadID = 1; hSock = INVALID_SOCKET; (*syslog_local).hSyslogdSock = INVALID_SOCKET; bCPUTickWorks = 1; nLogLevel = LOG_NOISE-1; // default log EVERYTHING #ifdef __ANDROID__ { logtype = SYSLOG_SYSTEM; nLogLevel = LOG_NOISE + 1000; // default log EVERYTHING (*syslog_local).flags.bLogSourceFile = 1; (*syslog_local).flags.bUseDeltaTime = 1; (*syslog_local).flags.bLogCPUTime = 1; (*syslog_local).flags.bLogThreadID = 1; (*syslog_local).flags.bLogProgram = 0; SystemLogTime( SYSLOG_TIME_HIGH ); } #else # if defined( _DEBUG ) || 1 { # ifdef __LINUX__ logtype = SYSLOG_SOCKET_SYSLOGD; (*syslog_local).flags.bLogProgram = 1; # else /* using SYSLOG_AUTO_FILE option does not require this to be open. * it is opened on demand. */ logtype = SYSLOG_AUTO_FILE; (*syslog_local).flags.bLogOpenBackup = 1; (*syslog_local).flags.bUseDeltaTime = 1; (*syslog_local).flags.bLogCPUTime = 1; (*syslog_local).flags.bUseDeltaTime = 1; (*syslog_local).flags.bLogCPUTime = 1; (*syslog_local).flags.bLogProgram = 0; SystemLogTime( SYSLOG_TIME_HIGH ); # endif nLogLevel = LOG_NOISE + 1000; // default log EVERYTHING (*syslog_local).flags.bLogOpenAppend = 0; (*syslog_local).flags.bLogSourceFile = 1; (*syslog_local).flags.bLogThreadID = 1; //SetDefaultName( NULL, NULL, NULL ); //lprintf( WIDE("Syslog Initializing, debug mode, startup programname.log\n") ); } # else // stderr? logtype = SYSLOG_NONE; (*syslog_local).file = NULL; # endif #endif (*syslog_local).flags.bInitialized = 1; } #ifndef __NO_OPTIONS__ if( !ignore_options ) LoadOptions(); #else (*syslog_local).flags.bOptionsLoaded = 1; # ifndef __ANDROID__ SetDefaultName( NULL, NULL, NULL ); # endif #endif }
/* Thread context management */ static void init_keys( void ) { pthread_key_create( &thread_key, NULL ); } /* init_keys */
int start_async(struct async *async) { int need_in, need_out; int fdin[2], fdout[2]; int proc_in, proc_out; need_in = async->in < 0; if (need_in) { if (pipe(fdin) < 0) { if (async->out > 0) close(async->out); return error("cannot create pipe: %s", strerror(errno)); } async->in = fdin[1]; } need_out = async->out < 0; if (need_out) { if (pipe(fdout) < 0) { if (need_in) close_pair(fdin); else if (async->in) close(async->in); return error("cannot create pipe: %s", strerror(errno)); } async->out = fdout[0]; } if (need_in) proc_in = fdin[0]; else if (async->in) proc_in = async->in; else proc_in = -1; if (need_out) proc_out = fdout[1]; else if (async->out) proc_out = async->out; else proc_out = -1; #ifdef NO_PTHREADS /* Flush stdio before fork() to avoid cloning buffers */ fflush(NULL); async->pid = fork(); if (async->pid < 0) { error("fork (async) failed: %s", strerror(errno)); goto error; } if (!async->pid) { if (need_in) close(fdin[1]); if (need_out) close(fdout[0]); git_atexit_clear(); process_is_async = 1; exit(!!async->proc(proc_in, proc_out, async->data)); } mark_child_for_cleanup(async->pid); if (need_in) close(fdin[0]); else if (async->in) close(async->in); if (need_out) close(fdout[1]); else if (async->out) close(async->out); #else if (!main_thread_set) { /* * We assume that the first time that start_async is called * it is from the main thread. */ main_thread_set = 1; main_thread = pthread_self(); pthread_key_create(&async_key, NULL); pthread_key_create(&async_die_counter, NULL); set_die_routine(die_async); set_die_is_recursing_routine(async_die_is_recursing); } if (proc_in >= 0) set_cloexec(proc_in); if (proc_out >= 0) set_cloexec(proc_out); async->proc_in = proc_in; async->proc_out = proc_out; { int err = pthread_create(&async->tid, NULL, run_thread, async); if (err) { error("cannot create thread: %s", strerror(err)); goto error; } } #endif return 0; error: if (need_in) close_pair(fdin); else if (async->in) close(async->in); if (need_out) close_pair(fdout); else if (async->out) close(async->out); return -1; }
static void initialize_key (void) { pthread_key_create (&sfi_key, free); }
static void local_region_make_key(void) { pthread_key_create( &local_region_key, local_region_destroy ); }
static void createThreadLocalKey() { (void)pthread_key_create( &static_key, NULL); }
static void mqueue_once_init(void) { pthread_key_create(&mqueue_key, mqueue_destructor); }