Reformat DTLS
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 3 Aug 2016 22:52:14 +0000 (15:52 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 4 Aug 2016 18:08:59 +0000 (11:08 -0700)
Did clang format, plus a bunch of things it didn't handle:

- block comments weren't wrapped
- functions with no arguments were not of the "void foo(void)" style
- no empty lines after local parameter declarations
- some trailing whitespace

It also moved around the include order.  Hopefully that didn't break
anything.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
user/parlib/dtls.c
user/parlib/include/parlib/dtls.h

index de1363b..157517d 100644 (file)
@@ -3,17 +3,17 @@
  *
  * See LICENSE for details. */
 
-#include <stddef.h>
 #include <parlib/assert.h>
-#include <parlib/spinlock.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 <sys/queue.h>
 #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
 
 /* The dynamic tls key structure */
 struct dtls_key {
-  int id;
-  int ref_count;
-  bool valid;
-  void (*dtor)(void*);
+       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;
-  void *dtls;
-}; 
+       TAILQ_ENTRY(dtls_value) link;
+       struct dtls_key *key;
+       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];
+       /* 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) */
@@ -52,179 +52,192 @@ 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 = false;
+static __thread bool __dtls_initialized;
 static struct dtls_key static_dtls_keys[NUM_STATIC_KEYS];
-static int num_dtls_keys = 0;
+static int num_dtls_keys;
 
 /* Initialize the slab caches for allocating dtls keys and values. */
-int dtls_cache_init()
+int dtls_cache_init(void)
 {
-  /* Make sure this only runs once */
-  static bool initialized = false;
-  if (initialized)
-      return 0;
-  initialized = true;
+       /* Make sure this only runs once */
+       static bool initialized;
 
-  /* 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);
+       if (initialized)
+               return 0;
+       initialized = true;
 
-  /* 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);
+       /* 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);
 
-  return 0;
+       /* 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);
+
+       return 0;
 }
 
-static dtls_key_t __allocate_dtls_key(
+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;
+       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);
+       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;
+       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);
+       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;
+       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);
+       assert(key);
+
+       key->valid = false;
+       __maybe_free_dtls_key(key);
 }
 
 static inline void *__get_dtls(dtls_data_t *dtls_data, dtls_key_t key)
 {
-  assert(key);
-
-  struct dtls_value *v;
-  if (key->id < NUM_STATIC_KEYS) {
-    v = &dtls_data->early_values[key->id];
-    if (v->key != NULL)
-      return v->dtls;
-  } else {
-    TAILQ_FOREACH(v, &dtls_data->list, link)
-      if (v->key == key)
-        return v->dtls;
-  }
-  return NULL;
+       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->dtls;
+       } else {
+               TAILQ_FOREACH(v, &dtls_data->list, link)
+                       if (v->key == key)
+                               return v->dtls;
+       }
+       return NULL;
 }
 
-static inline void __set_dtls(dtls_data_t *dtls_data, dtls_key_t key, void *dtls)
+static inline void __set_dtls(dtls_data_t *dtls_data, dtls_key_t key,
+                              void *dtls)
 {
-  assert(key);
-
-  struct dtls_value *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;
+       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;
-  v = TAILQ_FIRST(&dtls_data->list);
-  while(v != NULL) {
-    dtls_key_t 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) {
-         void *dtls = v->dtls;
-      v->dtls = NULL;
-      key->dtor(dtls);
-    }
-    __maybe_free_dtls_key(key);
-
-    n = TAILQ_NEXT(v, link);
-    TAILQ_REMOVE(&dtls_data->list, v, link);
-    __free_dtls_value(v);
-    v = n;
-  }
+       struct dtls_value *v, *n;
+       dtls_key_t key;
+       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(dtls);
+               }
+               __maybe_free_dtls_key(key);
+
+               n = TAILQ_NEXT(v, link);
+               TAILQ_REMOVE(&dtls_data->list, v, link);
+               __free_dtls_value(v);
+               v = n;
+       }
 }
 
 void set_dtls(dtls_key_t key, 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);
+       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;
-  if(!__dtls_initialized)
-    return NULL;
-  dtls_data = &__dtls_data;
-  return __get_dtls(dtls_data, key);
+       dtls_data_t *dtls_data = NULL;
+
+       if (!__dtls_initialized)
+               return NULL;
+       dtls_data = &__dtls_data;
+       return __get_dtls(dtls_data, key);
 }
 
-void destroy_dtls()
+void destroy_dtls(void)
 {
-  dtls_data_t *dtls_data = NULL;
-  if(!__dtls_initialized)
-    return;
-  dtls_data = &__dtls_data;
-  __destroy_dtls(dtls_data);
-}
+       dtls_data_t *dtls_data = NULL;
 
+       if (!__dtls_initialized)
+               return;
+       dtls_data = &__dtls_data;
+       __destroy_dtls(dtls_data);
+}
index 3c97c16..5052e61 100644 (file)
 __BEGIN_DECLS
 
 #ifndef __GNUC__
-  #error "You need to be using gcc to compile this library..."
-#endif 
+#error "You need to be using gcc to compile this library..."
+#endif
 
 /* Declaration of types needed for dynamically allocatable tls */
 typedef struct dtls_key *dtls_key_t;
-typedef void (*dtls_dtor_t)(void*);
+typedef void (*dtls_dtor_t)(void *);
 
 /* Initialize a dtls_key for dynamically setting/getting uthread local storage
  * on a uthread or vcore. */
@@ -25,13 +25,15 @@ dtls_key_t dtls_key_create(dtls_dtor_t dtor);
 /* Destroy a dtls key. */
 void dtls_key_delete(dtls_key_t key);
 
-/* Set dtls storage for the provided dtls key on the current uthread or vcore. */
+/* Set dtls storage for the provided dtls key on the current uthread or vcore.
+ */
 void set_dtls(dtls_key_t key, void *dtls);
 
-/* Get dtls storage for the provided dtls key on the current uthread or vcore. */
+/* Get dtls storage for the provided dtls key on the current uthread or vcore.
+ */
 void *get_dtls(dtls_key_t key);
 
 /* Destroy all dtls storage associated with the current uthread or vcore. */
-void destroy_dtls();
+void destroy_dtls(void);
 
 __END_DECLS