user/parlib/dtls.c - upstream - Git at Google

 /* Copyright (c) 2012 The Regents of the University of California
  * Kevin Klues <klueska@cs.berkeley.edu>
  *
  * See LICENSE for details. */

 #include <parlib/assert.h>
 #include <parlib/dtls.h>
 #include <parlib/slab.h>
 #include <parlib/spinlock.h>
 #include <stddef.h>

 /* The current dymamic tls implementation uses a locked linked list
  * to find the key for a given thread. We should probably find a better way to
  * do this based on a custom lock-free hash table or something. */
 #include <parlib/spinlock.h>
 #include <sys/queue.h>

 /* Define some number of static keys, for which the memory containing the keys
  * and the per-thread memory for the values associated with those keys is
  * allocated statically. This is adapted from glibc's notion of the
  * "specific_1stblock" field embedded directly into its pthread structure for
  * pthread_get/specific() calls. */
 #define NUM_STATIC_KEYS 32

 /* The dynamic tls key structure */
 struct dtls_key {
 	int id;
 	int ref_count;
 	bool valid;
 	void (*dtor)(void *);
 };

 /* The definition of a dtls_key list and its elements */
 struct dtls_value {
 	TAILQ_ENTRY(dtls_value) link;
 	struct dtls_key *key;
 	const void *dtls;
 };
 TAILQ_HEAD(dtls_list, dtls_value);

 /* A struct containing all of the per thread (i.e. vcore or uthread) data
  * associated with dtls */
 typedef struct dtls_data {
 	/* A per-thread list of dtls regions */
 	struct dtls_list list;
 	/* Memory to hold dtls values for the first NUM_STATIC_KEYS keys */
 	struct dtls_value early_values[NUM_STATIC_KEYS];
 } dtls_data_t;

 /* A slab of dtls keys (global to all threads) */
 static struct kmem_cache *__dtls_keys_cache;

 /* A slab of values for use when mapping a dtls_key to its per-thread value */
 struct kmem_cache *__dtls_values_cache;

 static __thread dtls_data_t __dtls_data;
 static __thread bool __dtls_initialized;
 static struct dtls_key static_dtls_keys[NUM_STATIC_KEYS];
 static int num_dtls_keys;

 /* Initialize the slab caches for allocating dtls keys and values. */
 int dtls_cache_init(void)
 {
 	/* Make sure this only runs once */
 	static bool initialized;

 	if (initialized)
 		return 0;
 	initialized = true;

 	/* Initialize the global cache of dtls_keys */
 	__dtls_keys_cache =
 	    kmem_cache_create("dtls_keys_cache", sizeof(struct dtls_key),
 			      __alignof__(struct dtls_key), 0, NULL, NULL,
 			      NULL);

 	/* Initialize the global cache of dtls_values */
 	__dtls_values_cache =
 	    kmem_cache_create("dtls_values_cache", sizeof(struct dtls_value),
 			      __alignof__(struct dtls_value), 0, NULL, NULL,
 			      NULL);

 	return 0;
 }

 static dtls_key_t __allocate_dtls_key(void)
 {
 	dtls_key_t key;
 	int keyid = __sync_fetch_and_add(&num_dtls_keys, 1);

 	if (keyid < NUM_STATIC_KEYS) {
 		key = &static_dtls_keys[keyid];
 	} else {
 		dtls_cache_init();
 		key = kmem_cache_alloc(__dtls_keys_cache, 0);
 	}
 	assert(key);
 	key->id = keyid;
 	key->ref_count = 1;
 	return key;
 }

 static void __maybe_free_dtls_key(dtls_key_t key)
 {
 	int ref_count = __sync_add_and_fetch(&key->ref_count, -1);

 	if (ref_count == 0 && key->id >= NUM_STATIC_KEYS)
 		kmem_cache_free(__dtls_keys_cache, key);
 }

 static struct dtls_value *__allocate_dtls_value(struct dtls_data *dtls_data,
                                                 struct dtls_key *key)
 {
 	struct dtls_value *v;

 	if (key->id < NUM_STATIC_KEYS)
 		v = &dtls_data->early_values[key->id];
 	else
 		v = kmem_cache_alloc(__dtls_values_cache, 0);
 	assert(v);
 	return v;
 }

 static void __free_dtls_value(struct dtls_value *v)
 {
 	if (v->key->id >= NUM_STATIC_KEYS)
 		kmem_cache_free(__dtls_values_cache, v);
 }

 dtls_key_t dtls_key_create(dtls_dtor_t dtor)
 {
 	dtls_key_t key = __allocate_dtls_key();

 	key->valid = true;
 	key->dtor = dtor;
 	return key;
 }

 void dtls_key_delete(dtls_key_t key)
 {
 	assert(key);

 	key->valid = false;
 	__maybe_free_dtls_key(key);
 }

 static inline struct dtls_value *__get_dtls(dtls_data_t *dtls_data,
                                             dtls_key_t key)
 {
 	struct dtls_value *v;

 	assert(key);
 	if (key->id < NUM_STATIC_KEYS) {
 		v = &dtls_data->early_values[key->id];
 		if (v->key != NULL)
 			return v;
 	} else {
 		TAILQ_FOREACH(v, &dtls_data->list, link)
 			if (v->key == key)
 				return v;
 	}
 	return NULL;
 }

 static inline void __set_dtls(dtls_data_t *dtls_data, dtls_key_t key,
                               const void *dtls)
 {
 	struct dtls_value *v;

 	assert(key);
 	v = __get_dtls(dtls_data, key);
 	if (!v) {
 		v = __allocate_dtls_value(dtls_data, key);
 		__sync_fetch_and_add(&key->ref_count, 1);
 		v->key = key;
 		TAILQ_INSERT_HEAD(&dtls_data->list, v, link);
 	}
 	v->dtls = dtls;
 }

 static inline void __destroy_dtls(dtls_data_t *dtls_data)
 {
 	struct dtls_value *v, *n;
 	dtls_key_t key;
 	const void *dtls;

 	v = TAILQ_FIRST(&dtls_data->list);
 	while (v != NULL) {
 		key = v->key;
 		/* The dtor must be called outside of a spinlock so that it can
 		 * call code that may deschedule it for a while (i.e. a mutex).
 		 * Probably a good idea anyway since it can be arbitrarily long
 		 * and is written by the user. Note, there is a small race here
 		 * on the valid field, whereby we may run a destructor on an
 		 * invalid key. At least the keys memory wont be deleted though,
 		 * as protected by the ref count. Any reasonable usage of this
 		 * interface should safeguard that a key is never destroyed
 		 * before all of the threads that use it have exited anyway. */
 		if (key->valid && key->dtor) {
 			dtls = v->dtls;
 			v->dtls = NULL;
 			key->dtor((void*)dtls);
 		}
 		n = TAILQ_NEXT(v, link);
 		TAILQ_REMOVE(&dtls_data->list, v, link);
 		/* Free both the key (which is v->key) and v *after* removing v
 		 * from the list.  It's possible that free() will call back into
 		 * the DTLS (e.g.  pthread_getspecific()), and v must be off the
 		 * list by then.
 		 *
 		 * For a similar, hilarious bug in glibc, check out:
 		 * https://sourceware.org/bugzilla/show_bug.cgi?id=3317 */
 		__maybe_free_dtls_key(key);
 		__free_dtls_value(v);
 		v = n;
 	}
 }

 void set_dtls(dtls_key_t key, const void *dtls)
 {
 	bool initialized = true;
 	dtls_data_t *dtls_data = NULL;

 	if (!__dtls_initialized) {
 		initialized = false;
 		__dtls_initialized = true;
 	}
 	dtls_data = &__dtls_data;
 	if (!initialized)
 		TAILQ_INIT(&dtls_data->list);
 	__set_dtls(dtls_data, key, dtls);
 }

 void *get_dtls(dtls_key_t key)
 {
 	dtls_data_t *dtls_data = NULL;
 	struct dtls_value *v;

 	if (!__dtls_initialized)
 		return NULL;
 	dtls_data = &__dtls_data;
 	v = __get_dtls(dtls_data, key);
 	return v ? (void*)v->dtls : NULL;
 }

 void destroy_dtls(void)
 {
 	dtls_data_t *dtls_data = NULL;

 	if (!__dtls_initialized)
 		return;
 	dtls_data = &__dtls_data;
 	__destroy_dtls(dtls_data);
 }
	/* Copyright (c) 2012 The Regents of the University of California
	* Kevin Klues <klueska@cs.berkeley.edu>
	*
	* See LICENSE for details. */

	#include <parlib/assert.h>
	#include <parlib/dtls.h>
	#include <parlib/slab.h>
	#include <parlib/spinlock.h>
	#include <stddef.h>

	/* The current dymamic tls implementation uses a locked linked list
	* to find the key for a given thread. We should probably find a better way to
	* do this based on a custom lock-free hash table or something. */
	#include <parlib/spinlock.h>
	#include <sys/queue.h>

	/* Define some number of static keys, for which the memory containing the keys
	* and the per-thread memory for the values associated with those keys is
	* allocated statically. This is adapted from glibc's notion of the
	* "specific_1stblock" field embedded directly into its pthread structure for
	* pthread_get/specific() calls. */
	#define NUM_STATIC_KEYS 32

	/* The dynamic tls key structure */
	struct dtls_key {
	int id;
	int ref_count;
	bool valid;
	void (dtor)(void );
	};

	/* The definition of a dtls_key list and its elements */
	struct dtls_value {
	TAILQ_ENTRY(dtls_value) link;
	struct dtls_key *key;
	const void *dtls;
	};
	TAILQ_HEAD(dtls_list, dtls_value);

	/* A struct containing all of the per thread (i.e. vcore or uthread) data
	* associated with dtls */
	typedef struct dtls_data {
	/* A per-thread list of dtls regions */
	struct dtls_list list;
	/* Memory to hold dtls values for the first NUM_STATIC_KEYS keys */
	struct dtls_value early_values[NUM_STATIC_KEYS];
	} dtls_data_t;

	/* A slab of dtls keys (global to all threads) */
	static struct kmem_cache *__dtls_keys_cache;

	/* A slab of values for use when mapping a dtls_key to its per-thread value */
	struct kmem_cache *__dtls_values_cache;

	static __thread dtls_data_t __dtls_data;
	static __thread bool __dtls_initialized;
	static struct dtls_key static_dtls_keys[NUM_STATIC_KEYS];
	static int num_dtls_keys;

	/* Initialize the slab caches for allocating dtls keys and values. */
	int dtls_cache_init(void)
	{
	/* Make sure this only runs once */
	static bool initialized;

	if (initialized)
	return 0;
	initialized = true;

	/* Initialize the global cache of dtls_keys */
	__dtls_keys_cache =
	kmem_cache_create("dtls_keys_cache", sizeof(struct dtls_key),
	__alignof__(struct dtls_key), 0, NULL, NULL,
	NULL);

	/* Initialize the global cache of dtls_values */
	__dtls_values_cache =
	kmem_cache_create("dtls_values_cache", sizeof(struct dtls_value),
	__alignof__(struct dtls_value), 0, NULL, NULL,
	NULL);

	return 0;
	}

	static dtls_key_t __allocate_dtls_key(void)
	{
	dtls_key_t key;
	int keyid = __sync_fetch_and_add(&num_dtls_keys, 1);

	if (keyid < NUM_STATIC_KEYS) {
	key = &static_dtls_keys[keyid];
	} else {
	dtls_cache_init();
	key = kmem_cache_alloc(__dtls_keys_cache, 0);
	}
	assert(key);
	key->id = keyid;
	key->ref_count = 1;
	return key;
	}

	static void __maybe_free_dtls_key(dtls_key_t key)
	{
	int ref_count = __sync_add_and_fetch(&key->ref_count, -1);

	if (ref_count == 0 && key->id >= NUM_STATIC_KEYS)
	kmem_cache_free(__dtls_keys_cache, key);
	}

	static struct dtls_value __allocate_dtls_value(struct dtls_data dtls_data,
	struct dtls_key *key)
	{
	struct dtls_value *v;

	if (key->id < NUM_STATIC_KEYS)
	v = &dtls_data->early_values[key->id];
	else
	v = kmem_cache_alloc(__dtls_values_cache, 0);
	assert(v);
	return v;
	}

	static void __free_dtls_value(struct dtls_value *v)
	{
	if (v->key->id >= NUM_STATIC_KEYS)
	kmem_cache_free(__dtls_values_cache, v);
	}

	dtls_key_t dtls_key_create(dtls_dtor_t dtor)
	{
	dtls_key_t key = __allocate_dtls_key();

	key->valid = true;
	key->dtor = dtor;
	return key;
	}

	void dtls_key_delete(dtls_key_t key)
	{
	assert(key);

	key->valid = false;
	__maybe_free_dtls_key(key);
	}

	static inline struct dtls_value __get_dtls(dtls_data_t dtls_data,
	dtls_key_t key)
	{
	struct dtls_value *v;

	assert(key);
	if (key->id < NUM_STATIC_KEYS) {
	v = &dtls_data->early_values[key->id];
	if (v->key != NULL)
	return v;
	} else {
	TAILQ_FOREACH(v, &dtls_data->list, link)
	if (v->key == key)
	return v;
	}
	return NULL;
	}

	static inline void __set_dtls(dtls_data_t *dtls_data, dtls_key_t key,
	const void *dtls)
	{
	struct dtls_value *v;

	assert(key);
	v = __get_dtls(dtls_data, key);
	if (!v) {
	v = __allocate_dtls_value(dtls_data, key);
	__sync_fetch_and_add(&key->ref_count, 1);
	v->key = key;
	TAILQ_INSERT_HEAD(&dtls_data->list, v, link);
	}
	v->dtls = dtls;
	}

	static inline void __destroy_dtls(dtls_data_t *dtls_data)
	{
	struct dtls_value v, n;
	dtls_key_t key;
	const void *dtls;

	v = TAILQ_FIRST(&dtls_data->list);
	while (v != NULL) {
	key = v->key;
	/* The dtor must be called outside of a spinlock so that it can
	* call code that may deschedule it for a while (i.e. a mutex).
	* Probably a good idea anyway since it can be arbitrarily long
	* and is written by the user. Note, there is a small race here
	* on the valid field, whereby we may run a destructor on an
	* invalid key. At least the keys memory wont be deleted though,
	* as protected by the ref count. Any reasonable usage of this
	* interface should safeguard that a key is never destroyed
	* before all of the threads that use it have exited anyway. */
	if (key->valid && key->dtor) {
	dtls = v->dtls;
	v->dtls = NULL;
	key->dtor((void*)dtls);
	}
	n = TAILQ_NEXT(v, link);
	TAILQ_REMOVE(&dtls_data->list, v, link);
	/* Free both the key (which is v->key) and v after removing v
	* from the list. It's possible that free() will call back into
	* the DTLS (e.g. pthread_getspecific()), and v must be off the
	* list by then.
	*
	* For a similar, hilarious bug in glibc, check out:
	* https://sourceware.org/bugzilla/show_bug.cgi?id=3317 */
	__maybe_free_dtls_key(key);
	__free_dtls_value(v);
	v = n;
	}
	}

	void set_dtls(dtls_key_t key, const void *dtls)
	{
	bool initialized = true;
	dtls_data_t *dtls_data = NULL;

	if (!__dtls_initialized) {
	initialized = false;
	__dtls_initialized = true;
	}
	dtls_data = &__dtls_data;
	if (!initialized)
	TAILQ_INIT(&dtls_data->list);
	__set_dtls(dtls_data, key, dtls);
	}

	void *get_dtls(dtls_key_t key)
	{
	dtls_data_t *dtls_data = NULL;
	struct dtls_value *v;

	if (!__dtls_initialized)
	return NULL;
	dtls_data = &__dtls_data;
	v = __get_dtls(dtls_data, key);
	return v ? (void*)v->dtls : NULL;
	}

	void destroy_dtls(void)
	{
	dtls_data_t *dtls_data = NULL;

	if (!__dtls_initialized)
	return;
	dtls_data = &__dtls_data;
	__destroy_dtls(dtls_data);
	}