#include "ovs-thread.h"
#include <errno.h>
#include <poll.h>
+#ifndef _WIN32
+#include <signal.h>
+#endif
#include <stdlib.h>
#include <unistd.h>
#include "compiler.h"
#include "hash.h"
+#include "netdev-dpdk.h"
#include "ovs-rcu.h"
#include "poll-loop.h"
+#include "seq.h"
#include "socket-util.h"
#include "util.h"
OVS_NO_THREAD_SAFETY_ANALYSIS \
{ \
struct ovs_##TYPE *l = CONST_CAST(struct ovs_##TYPE *, l_); \
- int error = pthread_##TYPE##_##FUN(&l->lock); \
+ int error; \
+ \
+ /* Verify that 'l' was initialized. */ \
+ if (OVS_UNLIKELY(!l->where)) { \
+ ovs_abort(0, "%s: %s() passed uninitialized ovs_"#TYPE, \
+ where, __func__); \
+ } \
+ \
+ error = pthread_##TYPE##_##FUN(&l->lock); \
if (OVS_UNLIKELY(error)) { \
- ovs_abort(error, "pthread_%s_%s failed", #TYPE, #FUN); \
+ ovs_abort(error, "%s: pthread_%s_%s failed", where, #TYPE, #FUN); \
} \
l->where = where; \
- }
+ }
LOCK_FUNCTION(mutex, lock);
LOCK_FUNCTION(rwlock, rdlock);
LOCK_FUNCTION(rwlock, wrlock);
OVS_NO_THREAD_SAFETY_ANALYSIS \
{ \
struct ovs_##TYPE *l = CONST_CAST(struct ovs_##TYPE *, l_); \
- int error = pthread_##TYPE##_##FUN(&l->lock); \
+ int error; \
+ \
+ /* Verify that 'l' was initialized. */ \
+ if (OVS_UNLIKELY(!l->where)) { \
+ ovs_abort(0, "%s: %s() passed uninitialized ovs_"#TYPE, \
+ where, __func__); \
+ } \
+ \
+ error = pthread_##TYPE##_##FUN(&l->lock); \
if (OVS_UNLIKELY(error) && error != EBUSY) { \
- ovs_abort(error, "pthread_%s_%s failed", #TYPE, #FUN); \
+ ovs_abort(error, "%s: pthread_%s_%s failed", where, #TYPE, #FUN); \
} \
if (!error) { \
l->where = where; \
TRY_LOCK_FUNCTION(rwlock, tryrdlock);
TRY_LOCK_FUNCTION(rwlock, trywrlock);
-#define UNLOCK_FUNCTION(TYPE, FUN) \
+#define UNLOCK_FUNCTION(TYPE, FUN, WHERE) \
void \
ovs_##TYPE##_##FUN(const struct ovs_##TYPE *l_) \
OVS_NO_THREAD_SAFETY_ANALYSIS \
{ \
struct ovs_##TYPE *l = CONST_CAST(struct ovs_##TYPE *, l_); \
int error; \
- l->where = NULL; \
+ \
+ /* Verify that 'l' was initialized. */ \
+ ovs_assert(l->where); \
+ \
+ l->where = WHERE; \
error = pthread_##TYPE##_##FUN(&l->lock); \
if (OVS_UNLIKELY(error)) { \
ovs_abort(error, "pthread_%s_%sfailed", #TYPE, #FUN); \
} \
}
-UNLOCK_FUNCTION(mutex, unlock);
-UNLOCK_FUNCTION(mutex, destroy);
-UNLOCK_FUNCTION(rwlock, unlock);
-UNLOCK_FUNCTION(rwlock, destroy);
+UNLOCK_FUNCTION(mutex, unlock, "<unlocked>");
+UNLOCK_FUNCTION(mutex, destroy, NULL);
+UNLOCK_FUNCTION(rwlock, unlock, "<unlocked>");
+UNLOCK_FUNCTION(rwlock, destroy, NULL);
#define XPTHREAD_FUNC1(FUNCTION, PARAM1) \
void \
XPTHREAD_FUNC1(pthread_cond_signal, pthread_cond_t *);
XPTHREAD_FUNC1(pthread_cond_broadcast, pthread_cond_t *);
-XPTHREAD_FUNC3(pthread_barrier_init, pthread_barrier_t *,
- pthread_barrierattr_t *, unsigned int);
-XPTHREAD_FUNC1(pthread_barrier_destroy, pthread_barrier_t *);
-
XPTHREAD_FUNC2(pthread_join, pthread_t, void **);
typedef void destructor_func(void *);
XPTHREAD_FUNC1(pthread_key_delete, pthread_key_t);
XPTHREAD_FUNC2(pthread_setspecific, pthread_key_t, const void *);
+#ifndef _WIN32
+XPTHREAD_FUNC3(pthread_sigmask, int, const sigset_t *, sigset_t *);
+#endif
+
static void
ovs_mutex_init__(const struct ovs_mutex *l_, int type)
{
pthread_mutexattr_t attr;
int error;
- l->where = NULL;
+ l->where = "<unlocked>";
xpthread_mutexattr_init(&attr);
xpthread_mutexattr_settype(&attr, type);
error = pthread_mutex_init(&l->lock, &attr);
pthread_rwlockattr_t attr;
int error;
- l->where = NULL;
+ l->where = "<unlocked>";
xpthread_rwlockattr_init(&attr);
#ifdef PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
}
}
-int
-xpthread_barrier_wait(pthread_barrier_t *barrier)
+/* Initializes the 'barrier'. 'size' is the number of threads
+ * expected to hit the barrier. */
+void
+ovs_barrier_init(struct ovs_barrier *barrier, uint32_t size)
{
- int error;
+ barrier->size = size;
+ atomic_init(&barrier->count, 0);
+ barrier->seq = seq_create();
+}
- ovsrcu_quiesce_start();
- error = pthread_barrier_wait(barrier);
- ovsrcu_quiesce_end();
+/* Destroys the 'barrier'. */
+void
+ovs_barrier_destroy(struct ovs_barrier *barrier)
+{
+ seq_destroy(barrier->seq);
+}
- if (error && OVS_UNLIKELY(error != PTHREAD_BARRIER_SERIAL_THREAD)) {
- ovs_abort(error, "pthread_barrier_wait failed");
+/* Makes the calling thread block on the 'barrier' until all
+ * 'barrier->size' threads hit the barrier. */
+void
+ovs_barrier_block(struct ovs_barrier *barrier)
+{
+ uint64_t seq = seq_read(barrier->seq);
+ uint32_t orig;
+
+ atomic_add(&barrier->count, 1, &orig);
+ if (orig + 1 == barrier->size) {
+ atomic_store(&barrier->count, 0);
+ seq_change(barrier->seq);
}
- return error;
+ /* To prevent thread from waking up by other event,
+ * keeps waiting for the change of 'barrier->seq'. */
+ while (seq == seq_read(barrier->seq)) {
+ seq_wait(barrier->seq, seq);
+ poll_block();
+ }
}
\f
DEFINE_EXTERN_PER_THREAD_DATA(ovsthread_id, 0);
struct ovsthread_aux {
void *(*start)(void *);
void *arg;
+ char name[16];
};
static void *
aux = *auxp;
free(auxp);
+ /* The order of the following calls is important, because
+ * ovsrcu_quiesce_end() saves a copy of the thread name. */
+ set_subprogram_name("%s%u", aux.name, id);
ovsrcu_quiesce_end();
+
+ thread_set_nonpmd();
+
return aux.start(aux.arg);
}
-void
-xpthread_create(pthread_t *threadp, pthread_attr_t *attr,
- void *(*start)(void *), void *arg)
+/* Starts a thread that calls 'start(arg)'. Sets the thread's name to 'name'
+ * (suffixed by its ovsthread_id()). Returns the new thread's pthread_t. */
+pthread_t
+ovs_thread_create(const char *name, void *(*start)(void *), void *arg)
{
struct ovsthread_aux *aux;
pthread_t thread;
aux = xmalloc(sizeof *aux);
aux->start = start;
aux->arg = arg;
+ ovs_strlcpy(aux->name, name, sizeof aux->name);
- error = pthread_create(threadp ? threadp : &thread, attr,
- ovsthread_wrapper, aux);
+ error = pthread_create(&thread, NULL, ovsthread_wrapper, aux);
if (error) {
ovs_abort(error, "pthread_create failed");
}
+ return thread;
}
\f
bool
projects / cascardo / ovs.git / blobdiff