/**
 * util/locks.c - unbound locking primitives
 *
 * Copyright (c) 2007, NLnet Labs. All rights reserved.
 * 
 * This software is open source.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * Neither the name of the NLNET LABS nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * \file
 * Implementation of locking and threading support.
 * A place for locking debug code since most locking functions are macros.
 */

#include "config.h"
#include "util/locks.h"
#include <signal.h>
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif

/** block all signals, masks them away. */
void 
ub_thread_blocksigs(void)
{
#if defined(HAVE_PTHREAD) || defined(HAVE_SOLARIS_THREADS) || defined(HAVE_SIGPROCMASK)
#  if defined(HAVE_PTHREAD) || defined(HAVE_SOLARIS_THREADS)
        int err;
#  endif
        sigset_t sigset;
        sigfillset(&sigset);
#ifdef HAVE_PTHREAD
        if((err=pthread_sigmask(SIG_SETMASK, &sigset, NULL)))
                fatal_exit("pthread_sigmask: %s", strerror(err));
#else
#  ifdef HAVE_SOLARIS_THREADS
        if((err=thr_sigsetmask(SIG_SETMASK, &sigset, NULL)))
                fatal_exit("thr_sigsetmask: %s", strerror(err));
#  else 
        /* have nothing, do single process signal mask */
        if(sigprocmask(SIG_SETMASK, &sigset, NULL))
                fatal_exit("sigprocmask: %s", strerror(errno));
#  endif /* HAVE_SOLARIS_THREADS */
#endif /* HAVE_PTHREAD */
#endif /* have signal stuff */
}

/** unblock one signal, so we can catch it */
void ub_thread_sig_unblock(int sig)
{
#if defined(HAVE_PTHREAD) || defined(HAVE_SOLARIS_THREADS) || defined(HAVE_SIGPROCMASK)
#  if defined(HAVE_PTHREAD) || defined(HAVE_SOLARIS_THREADS)
        int err;
#  endif
        sigset_t sigset;
        sigemptyset(&sigset);
        sigaddset(&sigset, sig);
#ifdef HAVE_PTHREAD
        if((err=pthread_sigmask(SIG_UNBLOCK, &sigset, NULL)))
                fatal_exit("pthread_sigmask: %s", strerror(err));
#else
#  ifdef HAVE_SOLARIS_THREADS
        if((err=thr_sigsetmask(SIG_UNBLOCK, &sigset, NULL)))
                fatal_exit("thr_sigsetmask: %s", strerror(err));
#  else 
        /* have nothing, do single thread case */
        if(sigprocmask(SIG_UNBLOCK, &sigset, NULL))
                fatal_exit("sigprocmask: %s", strerror(errno));
#  endif /* HAVE_SOLARIS_THREADS */
#endif /* HAVE_PTHREAD */
#else
        (void)sig;
#endif /* have signal stuff */
}

#if !defined(HAVE_PTHREAD) && !defined(HAVE_SOLARIS_THREADS) && !defined(HAVE_WINDOWS_THREADS)
/**
 * No threading available: fork a new process.
 * This means no shared data structure, and no locking.
 * Only the main thread ever returns. Exits on errors.
 * @param thr: the location where to store the thread-id.
 * @param func: function body of the thread. Return value of func is lost.
 * @param arg: user argument to func.
 */
void 
ub_thr_fork_create(ub_thread_type* thr, void* (*func)(void*), void* arg)
{
        pid_t pid = fork();
        switch(pid) {
        default:        /* main */
                        *thr = (ub_thread_type)pid;
                        return;
        case 0:         /* child */
                        *thr = (ub_thread_type)getpid();
                        (void)(*func)(arg);
                        exit(0);
        case -1:        /* error */
                        fatal_exit("could not fork: %s", strerror(errno));
        }
}

/**
 * There is no threading. Wait for a process to terminate.
 * Note that ub_thread_type is defined as pid_t.
 * @param thread: the process id to wait for.
 */
void ub_thr_fork_wait(ub_thread_type thread)
{
        int status = 0;
        if(waitpid((pid_t)thread, &status, 0) == -1)
                log_err("waitpid(%d): %s", (int)thread, strerror(errno));
        if(status != 0)
                log_warn("process %d abnormal exit with status %d",
                        (int)thread, status);
}
#endif /* !defined(HAVE_PTHREAD) && !defined(HAVE_SOLARIS_THREADS) && !defined(HAVE_WINDOWS_THREADS) */

#ifdef HAVE_SOLARIS_THREADS
void* ub_thread_key_get(ub_thread_key_type key)
{
        void* ret=NULL;
        LOCKRET(thr_getspecific(key, &ret));
        return ret;
}
#endif

#ifdef HAVE_WINDOWS_THREADS
/** log a windows GetLastError message */
static void log_win_err(const char* str, DWORD err)
{
        LPTSTR buf;
        if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | 
                FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER, 
                NULL, err, 0, (LPTSTR)&buf, 0, NULL) == 0) {
                /* could not format error message */
                log_err("%s, GetLastError=%d", str, (int)err);
                return;
        }
        log_err("%s, (err=%d): %s", str, (int)err, buf);
        LocalFree(buf);
}

void lock_basic_init(lock_basic_type* lock)
{
        /* implement own lock, because windows HANDLE as Mutex usage
         * uses too many handles and would bog down the whole system. */
        (void)InterlockedExchange(lock, 0);
}

void lock_basic_destroy(lock_basic_type* lock)
{
        (void)InterlockedExchange(lock, 0);
}

void lock_basic_lock(lock_basic_type* lock)
{
        LONG wait = 1; /* wait 1 msec at first */

        while(InterlockedExchange(lock, 1)) {
                /* if the old value was 1 then if was already locked */
                Sleep(wait); /* wait with sleep */
                wait *= 2;   /* exponential backoff for waiting */
        }
        /* the old value was 0, but we inserted 1, we locked it! */
}

void lock_basic_unlock(lock_basic_type* lock)
{
        /* unlock it by inserting the value of 0. xchg for cache coherency. */
        (void)InterlockedExchange(lock, 0);
}

void ub_thread_key_create(ub_thread_key_type* key, void* f)
{
        *key = TlsAlloc();
        if(*key == TLS_OUT_OF_INDEXES) {
                *key = 0;
                log_win_err("TlsAlloc Failed(OUT_OF_INDEXES)", GetLastError());
        }
        else ub_thread_key_set(*key, f);
}

void ub_thread_key_set(ub_thread_key_type key, void* v)
{
        if(!TlsSetValue(key, v)) {
                log_win_err("TlsSetValue failed", GetLastError());
        }
}

void* ub_thread_key_get(ub_thread_key_type key)
{
        void* ret = (void*)TlsGetValue(key);
        if(ret == NULL && GetLastError() != ERROR_SUCCESS) {
                log_win_err("TlsGetValue failed", GetLastError());
        }
        return ret;
}

void ub_thread_create(ub_thread_type* thr, void* (*func)(void*), void* arg)
{
#ifndef HAVE__BEGINTHREADEX
        *thr = CreateThread(NULL, /* default security (no inherit handle) */
                0, /* default stack size */
                (LPTHREAD_START_ROUTINE)func, arg,
                0, /* default flags, run immediately */
                NULL); /* do not store thread identifier anywhere */
#else
        /* the beginthreadex routine setups for the C lib; aligns stack */
        *thr=(ub_thread_type)_beginthreadex(NULL, 0, (void*)func, arg, 0, NULL);
#endif
        if(*thr == NULL) {
                log_win_err("CreateThread failed", GetLastError());
                fatal_exit("thread create failed");
        }
}

ub_thread_type ub_thread_self(void)
{
        return GetCurrentThread();
}

void ub_thread_join(ub_thread_type thr)
{
        DWORD ret = WaitForSingleObject(thr, INFINITE);
        if(ret == WAIT_FAILED) {
                log_win_err("WaitForSingleObject(Thread):WAIT_FAILED", 
                        GetLastError());
        } else if(ret == WAIT_TIMEOUT) {
                log_win_err("WaitForSingleObject(Thread):WAIT_TIMEOUT", 
                        GetLastError());
        }
        /* and close the handle to the thread */
        if(!CloseHandle(thr)) {
                log_win_err("CloseHandle(Thread) failed", GetLastError());
        }
}
#endif /* HAVE_WINDOWS_THREADS */