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);
}

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, &param);
#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));
}

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);
}

/* 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);
}