src/xcalls/x_pthread_mutex_lock.c

Go to the documentation of this file.

#include <pthread.h>
#include <core/tx.h>
#include <core/config.h>
#include <core/txdesc.h>
#include <misc/debug.h>
#include <misc/errno.h>
#include <xcalls/xcalls.h>

typedef struct x_undo_args_s x_undo_args_t;

struct x_undo_args_s {
        pthread_mutex_t *mutex;
};

static
void
x_pthread_mutex_lock_undo(void *args, int *result)
{
        x_undo_args_t *args_undo = (x_undo_args_t *) args;
        int           local_result = 0;
        int           ret;

        if ((ret = pthread_mutex_unlock(args_undo->mutex)) != 0) {
                local_result = ret;
        }
        if (result) {
                *result = local_result;
        }       
}

int
XCALL_DEF(x_pthread_mutex_lock)(pthread_mutex_t *mutex, int *result) 
{
        txc_tx_t      *txd;
        int           ret;
        x_undo_args_t *args_undo; 
        int           local_result = 0;

        txd = txc_tx_get_txd();

        switch(txc_tx_get_xactstate(txd)) {
                case TXC_XACTSTATE_TRANSACTIONAL_RETRYABLE:
                        args_undo = (x_undo_args_t *)
                                    txc_buffer_linear_malloc(txd->buffer_linear, 
                                                             sizeof(x_undo_args_t));
                        if (args_undo == NULL) {
                                TXC_INTERNALERROR("Allocation failed. Linear buffer out of space.\n");
                        }
                        args_undo->mutex = mutex;
                        if ((ret = pthread_mutex_trylock(mutex)) != 0) {
                                txc_tx_abort_transaction(txd, TXC_ABORTREASON_BUSYTXLOCK);
                                TXC_INTERNALERROR("Never gets here. Transaction abort failed.\n");
                        }       

                        txc_tx_register_undo_action(txd, x_pthread_mutex_lock_undo, 
                                                    (void *) args_undo, result,
                                                    TXC_TX_REGULAR_UNDO_ACTION_ORDER);
                        
                        break;
                case TXC_XACTSTATE_TRANSACTIONAL_IRREVOCABLE:
                case TXC_XACTSTATE_NONTRANSACTIONAL:
                        if ((ret = pthread_mutex_lock(mutex)) != 0) { 
                                local_result = ret;
                                goto done;
                        }
        }
done:
        if (result) {
                *result = local_result;
        }
        return ret;
}

---