myxce/src/lib/mylock.c

#include <errno.h>
#include <stdlib.h>
#include <string.h>

#include <rtti.h>

#include "mylock.h"

int mylock_init(mylock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_mutex_init(l, NULL);
}

void mylock_fini(mylock_t* l)
{
    if (l == NULL) {
        return;
    }

    pthread_mutex_destroy(l);
}
int mylock_try(mylock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_mutex_trylock(l);
}

int mylock_lock(mylock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_mutex_lock(l);
}

int mylock_unlock(mylock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_mutex_unlock(l);
}

int cbuf_init(cbuf_t* b, int cap, int isize)
{
    if ((b == NULL) || (cap <= 0) || (isize <= 0)) {
        return -EINVAL;
    }

    b->ncap  = cap;
    b->isize = isize;
    b->data  = (void*)calloc(cap, isize);

    if (b->data == NULL) {
        return -EINVAL;
    }

    b->head = 0;
    b->len  = 0;

    pthread_mutex_init(&(b->mutex), NULL);
    pthread_cond_init(&(b->condget), NULL);
    pthread_cond_init(&(b->condput), NULL);

    return 0;
}

void cbuf_fini(cbuf_t* b)
{
    if (b == NULL) {
        return;
    }

    if (b->data != NULL) {
        free(b->data);
        b->data = NULL;
    }

    pthread_mutex_destroy(&(b->mutex));
    pthread_cond_destroy(&(b->condput));
    pthread_cond_destroy(&(b->condget));
}

int cbuf_put(cbuf_t* b, void* it)
{
    int i;

    if ((b == NULL) || (it == NULL)) {
        return -EINVAL;
    }

    pthread_mutex_lock(&(b->mutex));
    /* pthread_cond_wait() reacquires the mutex before honoring a pending
     * cancellation (POSIX-mandated), so a caller cancelled while parked
     * here would otherwise terminate holding b->mutex forever -- no other
     * thread could ever lock it again. The cleanup handler releases it on
     * that unwind; on the normal (non-cancelled) path pop(0) just removes
     * the handler without running it, since the explicit unlock below
     * still runs. */
    pthread_cleanup_push((void (*)(void*))pthread_mutex_unlock, &(b->mutex));
    while (b->len == b->ncap) {
        pthread_cond_wait(&(b->condput), &(b->mutex));
    }
    pthread_cleanup_pop(0);

    i = (b->head + b->len) % b->ncap;

    memcpy((void*)((char*)b->data) + b->isize * i, it, b->isize);

    b->len++;

    pthread_cond_signal(&(b->condget));

    pthread_mutex_unlock(&(b->mutex));
    return 0;
}

int cbuf_tryput(cbuf_t* b, void* it)
{
    int i;
    int rc = 0;

    if ((b == NULL) || (it == NULL)) {
        return -EINVAL;
    }

    pthread_mutex_lock(&(b->mutex));
    if (b->len < b->ncap) {
        i = (b->head + b->len) % b->ncap;

        memcpy((void*)((char*)b->data) + b->isize * i, it, b->isize);

        b->len++;

        pthread_cond_signal(&(b->condget));
    } else {
        rc = -EAGAIN;
    }

    pthread_mutex_unlock(&(b->mutex));
    return rc;
}

int cbuf_get(cbuf_t* b, void* it)
{
    if ((b == NULL) || (it == NULL)) {
        return -EINVAL;
    }

    pthread_mutex_lock(&(b->mutex));
    /* See cbuf_put()'s comment on the same pattern: without this cleanup
     * handler, a caller cancelled while parked in pthread_cond_wait()
     * would reacquire and then abandon b->mutex locked forever. */
    pthread_cleanup_push((void (*)(void*))pthread_mutex_unlock, &(b->mutex));
    while (b->len == 0) {
        pthread_cond_wait(&(b->condget), &(b->mutex));
    }
    pthread_cleanup_pop(0);

    memcpy(it, (void*)((char*)b->data) + b->isize * b->head, b->isize);

    b->head = (b->head + 1) % b->ncap;
    b->len--;

    pthread_cond_signal(&(b->condput));

    pthread_mutex_unlock(&(b->mutex));
    return 0;
}

int cbuf_tryget(cbuf_t* b, void* it)
{
    int rc = 0;

    if ((b == NULL) || (it == NULL)) {
        return -EINVAL;
    }

    pthread_mutex_lock(&(b->mutex));
    if (b->len == 0) {
        rc = -EAGAIN;
    } else {
        memcpy(it, (void*)((char*)b->data) + b->isize * b->head, b->isize);

        b->head = (b->head + 1) % b->ncap;
        b->len--;

        pthread_cond_signal(&(b->condput));
    }
    pthread_mutex_unlock(&(b->mutex));

    return rc;
}

int cbuf_timedget(cbuf_t* b, void* it, const struct timespec* deadline)
{
    int timed_out = 0;

    if ((b == NULL) || (it == NULL) || (deadline == NULL)) {
        return -EINVAL;
    }

    pthread_mutex_lock(&(b->mutex));
    /* See cbuf_put()'s comment on the same pattern: without this cleanup
     * handler, a caller cancelled while parked in pthread_cond_timedwait()
     * would reacquire and then abandon b->mutex locked forever.
     * pthread_cleanup_push()/pop() must be a matched pair at the same
     * lexical nesting level -- break out of the loop on timeout instead
     * of returning from inside it, so pop() always runs right after. */
    pthread_cleanup_push((void (*)(void*))pthread_mutex_unlock, &(b->mutex));
    while (b->len == 0) {
        int rc = pthread_cond_timedwait(&(b->condget), &(b->mutex), deadline);
        if (rc == ETIMEDOUT) {
            timed_out = 1;
            break;
        }
    }
    pthread_cleanup_pop(0);

    if (timed_out) {
        pthread_mutex_unlock(&(b->mutex));
        return -ETIMEDOUT;
    }

    memcpy(it, (void*)((char*)b->data) + b->isize * b->head, b->isize);

    b->head = (b->head + 1) % b->ncap;
    b->len--;

    pthread_cond_signal(&(b->condput));

    pthread_mutex_unlock(&(b->mutex));
    return 0;
}

int my_rwlock_init(my_rwlock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_rwlock_init(l, NULL);
}

void my_rwlock_fini(my_rwlock_t* l)
{
    if (l == NULL) {
        return;
    }

    pthread_rwlock_destroy(l);
}

int my_rwlock_unlock(my_rwlock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_rwlock_unlock(l);
}

int my_rwlock_rlock(my_rwlock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_rwlock_rdlock(l);
}

int my_rwlock_wlock(my_rwlock_t* l)
{
    if (l == NULL) {
        return -EINVAL;
    }

    return pthread_rwlock_wrlock(l);
}