#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/prctl.h>
#include <ulocks.h>
#include <errno.h>

#define HDR_SIZE        2680    /* sizeof(ushdr_t) */
#define MAXPROC         100     /* max # of threads that can be started */

static usptr_t *shared_arena;
static ulock_t count_lock;      /* protection for some variables */
static ulock_t wait_lock;       /* lock used to wait for other threads */
static int waiting_for_threads; /* protected by count_lock */
static int nthreads;            /* protected by count_lock */
static int exit_status;
#ifndef NO_EXIT_PROG
static int do_exit;             /* indicates that the program is to exit */
#endif
static int exiting;             /* we're already exiting (for maybe_exit) */
static pid_t my_pid;            /* PID of main thread */
static struct pidlist {
    pid_t parent;
    pid_t child;
} pidlist[MAXPROC];     /* PIDs of other threads; protected by count_lock */
static int maxpidindex;         /* # of PIDs in pidlist */

#ifndef NO_EXIT_PROG
/*
 * This routine is called as a signal handler when another thread
 * exits.  When that happens, we must see whether we have to exit as
 * well (because of an PyThread_exit_prog()) or whether we should continue on.
 */
static void exit_sig(void)
{
    d2printf(("exit_sig called\n"));
    if (exiting && getpid() == my_pid) {
        d2printf(("already exiting\n"));
        return;
    }
    if (do_exit) {
        d2printf(("exiting in exit_sig\n"));
#ifdef Py_DEBUG
        if ((thread_debug & 8) == 0)
            thread_debug &= ~1; /* don't produce debug messages */
#endif
        PyThread_exit_thread();
    }
}

/*
 * This routine is called when a process calls exit().  If that wasn't
 * done from the library, we do as if an PyThread_exit_prog() was intended.
 */
static void maybe_exit(void)
{
    dprintf(("maybe_exit called\n"));
    if (exiting) {
        dprintf(("already exiting\n"));
        return;
    }
    PyThread_exit_prog(0);
}
#endif /* NO_EXIT_PROG */

/*
 * Initialization.
 */
static void PyThread__init_thread(void)
{
#ifndef NO_EXIT_PROG
    struct sigaction s;
#endif /* NO_EXIT_PROG */
#ifdef USE_DL
    long addr, size;
#endif /* USE_DL */


#ifdef USE_DL
    if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
        perror("usconfig - CONF_INITSIZE (check)");
    if (usconfig(CONF_INITSIZE, size) < 0)
        perror("usconfig - CONF_INITSIZE (reset)");
    addr = (long) dl_getrange(size + HDR_SIZE);
    dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));
    errno = 0;
    if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
        perror("usconfig - CONF_ATTACHADDR (set)");
#endif /* USE_DL */
    if (usconfig(CONF_INITUSERS, 16) < 0)
        perror("usconfig - CONF_INITUSERS");
    my_pid = getpid();          /* so that we know which is the main thread */
#ifndef NO_EXIT_PROG
    atexit(maybe_exit);
    s.sa_handler = exit_sig;
    sigemptyset(&s.sa_mask);
    /*sigaddset(&s.sa_mask, SIGUSR1);*/
    s.sa_flags = 0;
    sigaction(SIGUSR1, &s, 0);
    if (prctl(PR_SETEXITSIG, SIGUSR1) < 0)
        perror("prctl - PR_SETEXITSIG");
#endif /* NO_EXIT_PROG */
    if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)
        perror("usconfig - CONF_ARENATYPE");
    usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */
#ifdef Py_DEBUG
    if (thread_debug & 4)
        usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
    else if (thread_debug & 2)
        usconfig(CONF_LOCKTYPE, US_DEBUG);
#endif /* Py_DEBUG */
    if ((shared_arena = usinit(tmpnam(0))) == 0)
        perror("usinit");
#ifdef USE_DL
    if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
        perror("usconfig - CONF_ATTACHADDR (reset)");
#endif /* USE_DL */
    if ((count_lock = usnewlock(shared_arena)) == NULL)
        perror("usnewlock (count_lock)");
    (void) usinitlock(count_lock);
    if ((wait_lock = usnewlock(shared_arena)) == NULL)
        perror("usnewlock (wait_lock)");
    dprintf(("arena start: %p, arena size: %ld\n",  shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
}

/*
 * Thread support.
 */

static void clean_threads(void)
{
    int i, j;
    pid_t mypid, pid;

    /* clean up any exited threads */
    mypid = getpid();
    i = 0;
    while (i < maxpidindex) {
        if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) {
            pid = waitpid(pid, 0, WNOHANG);
            if (pid > 0) {
                /* a thread has exited */
                pidlist[i] = pidlist[--maxpidindex];
                /* remove references to children of dead proc */
                for (j = 0; j < maxpidindex; j++)
                    if (pidlist[j].parent == pid)
                        pidlist[j].child = -1;
                continue; /* don't increment i */
            }
        }
        i++;
    }
    /* clean up the list */
    i = 0;
    while (i < maxpidindex) {
        if (pidlist[i].child == -1) {
            pidlist[i] = pidlist[--maxpidindex];
            continue; /* don't increment i */
        }
        i++;
    }
}

long PyThread_start_new_thread(void (*func)(void *), void *arg)
{
#ifdef USE_DL
    long addr, size;
    static int local_initialized = 0;
#endif /* USE_DL */
    int success = 0;            /* init not needed when SOLARIS_THREADS and */
                /* C_THREADS implemented properly */

    dprintf(("PyThread_start_new_thread called\n"));
    if (!initialized)
        PyThread_init_thread();
    switch (ussetlock(count_lock)) {
    case 0: return 0;
    case -1: perror("ussetlock (count_lock)");
    }
    if (maxpidindex >= MAXPROC)
        success = -1;
    else {
#ifdef USE_DL
        if (!local_initialized) {
            if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
                perror("usconfig - CONF_INITSIZE (check)");
            if (usconfig(CONF_INITSIZE, size) < 0)
                perror("usconfig - CONF_INITSIZE (reset)");
            addr = (long) dl_getrange(size + HDR_SIZE);
            dprintf(("trying to use addr %p-%p for sproc\n",
                     addr, addr+size));
            errno = 0;
            if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&
                errno != 0)
                perror("usconfig - CONF_ATTACHADDR (set)");
        }
#endif /* USE_DL */
        clean_threads();
        if ((success = sproc(func, PR_SALL, arg)) < 0)
            perror("sproc");
#ifdef USE_DL
        if (!local_initialized) {
            if (usconfig(CONF_ATTACHADDR, addr) < 0)
                /* reset address */
                perror("usconfig - CONF_ATTACHADDR (reset)");
            local_initialized = 1;
        }
#endif /* USE_DL */
        if (success >= 0) {
            nthreads++;
            pidlist[maxpidindex].parent = getpid();
            pidlist[maxpidindex++].child = success;
            dprintf(("pidlist[%d] = %d\n",
                     maxpidindex-1, success));
        }
    }
    if (usunsetlock(count_lock) < 0)
        perror("usunsetlock (count_lock)");
    return success;
}

long PyThread_get_thread_ident(void)
{
    return getpid();
}

static void do_PyThread_exit_thread(int no_cleanup)
{
    dprintf(("PyThread_exit_thread called\n"));
    if (!initialized)
        if (no_cleanup)
            _exit(0);
        else
            exit(0);
    if (ussetlock(count_lock) < 0)
        perror("ussetlock (count_lock)");
    nthreads--;
    if (getpid() == my_pid) {
        /* main thread; wait for other threads to exit */
        exiting = 1;
#ifndef NO_EXIT_PROG
        if (do_exit) {
            int i;

            /* notify other threads */
            clean_threads();
            if (nthreads >= 0) {
                dprintf(("kill other threads\n"));
                for (i = 0; i < maxpidindex; i++)
                    if (pidlist[i].child > 0)
                        (void) kill(pidlist[i].child,
                                    SIGKILL);
                _exit(exit_status);
            }
        }
#endif /* NO_EXIT_PROG */
        waiting_for_threads = 1;
        if (ussetlock(wait_lock) < 0)
            perror("ussetlock (wait_lock)");
        for (;;) {
            if (nthreads < 0) {
                dprintf(("really exit (%d)\n", exit_status));
                if (no_cleanup)
                    _exit(exit_status);
                else
                    exit(exit_status);
            }
            if (usunsetlock(count_lock) < 0)
                perror("usunsetlock (count_lock)");
            dprintf(("waiting for other threads (%d)\n", nthreads));
            if (ussetlock(wait_lock) < 0)
                perror("ussetlock (wait_lock)");
            if (ussetlock(count_lock) < 0)
                perror("ussetlock (count_lock)");
        }
    }
    /* not the main thread */
    if (waiting_for_threads) {
        dprintf(("main thread is waiting\n"));
        if (usunsetlock(wait_lock) < 0)
            perror("usunsetlock (wait_lock)");
    }
#ifndef NO_EXIT_PROG
    else if (do_exit)
        (void) kill(my_pid, SIGUSR1);
#endif /* NO_EXIT_PROG */
    if (usunsetlock(count_lock) < 0)
        perror("usunsetlock (count_lock)");
    _exit(0);
}

void PyThread_exit_thread(void)
{
    do_PyThread_exit_thread(0);
}

void PyThread__exit_thread(void)
{
    do_PyThread_exit_thread(1);
}

#ifndef NO_EXIT_PROG
static void do_PyThread_exit_prog(int status, int no_cleanup)
{
    dprintf(("PyThread_exit_prog(%d) called\n", status));
    if (!initialized)
        if (no_cleanup)
            _exit(status);
        else
            exit(status);
    do_exit = 1;
    exit_status = status;
    do_PyThread_exit_thread(no_cleanup);
}

void PyThread_exit_prog(int status)
{
    do_PyThread_exit_prog(status, 0);
}

void PyThread__exit_prog(int status)
{
    do_PyThread_exit_prog(status, 1);
}
#endif /* NO_EXIT_PROG */

/*
 * Lock support.
 */
PyThread_type_lock PyThread_allocate_lock(void)
{
    ulock_t lock;

    dprintf(("PyThread_allocate_lock called\n"));
    if (!initialized)
        PyThread_init_thread();

    if ((lock = usnewlock(shared_arena)) == NULL)
        perror("usnewlock");
    (void) usinitlock(lock);
    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
    return (PyThread_type_lock) lock;
}

void PyThread_free_lock(PyThread_type_lock lock)
{
    dprintf(("PyThread_free_lock(%p) called\n", lock));
    usfreelock((ulock_t) lock, shared_arena);
}

int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
{
    int success;

    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
    errno = 0;                  /* clear it just in case */
    if (waitflag)
        success = ussetlock((ulock_t) lock);
    else
        success = uscsetlock((ulock_t) lock, 1); /* Try it once */
    if (success < 0)
        perror(waitflag ? "ussetlock" : "uscsetlock");
    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
    return success;
}

void PyThread_release_lock(PyThread_type_lock lock)
{
    dprintf(("PyThread_release_lock(%p) called\n", lock));
    if (usunsetlock((ulock_t) lock) < 0)
        perror("usunsetlock");
}