/*
 * Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * Implementation of HPI that can not be expressed with POSIX threads.
 * Note that even if you are building with USE_PTHREADS, we have to
 * explicitly undef it here because pthread.h and thread.h can not be
 * included in the same file, and this file needs only thread.h.
 */
#undef USE_PTHREADS

#include "hpi_impl.h"
#include "monitor_md.h"
#include "threads_md.h"
#include "np.h"

#include <thread.h>
#include <sys/lwp.h>
#include <signal.h>
#include <sys/signal.h>
#include <sys/resource.h>
#include <sys/procfs.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

#include <sys/syscall.h>
extern int syscall(int, ...);


/*
 * Forward declarations.
 */
static int  procfd;
static void stop_lwps();
static void clear_onproc_flags();
static void restart_lwps();
static void MakeProcName(register char *procname, register pid_t pid);
static void GC_msec_sleep(int n);


/*
 * Make sure that we link against a verion of libthread that has at least
 * the bug fixes and the interface for getting the stack from threads that
 * aren't on LWPs.  Otherwise we should exit with some informative message.
 */
extern ulong_t __gettsp(thread_t);

static const char * gettspMessage =
"You must install a Solaris patch to run the native threads version of the\n"
"Java runtime.  The green threads version will work without this patch.\n"
"Please check the native threads release notes for more information.\n"
"\n"
"If you are embedding the VM in a native application, please make sure that\n"
"the native application is linked with libthread.so (-lthread).\n"
"\n"
"Exiting.\n";

static void
checkForCorrectLibthread()
{
    if (&__gettsp == 0) {
        fprintf(stderr, gettspMessage);
        exit(1);
    }
}
#ifdef __GNUC__
static void checkForCorrectLibthread() __attribute__((constructor));
#else
#pragma init(checkForCorrectLibthread)
#endif

#pragma weak __gettsp


/*
 * Suspend said thread.  Used to implement java.lang.Thread.suspend(),
 * which is deprecated.
 */
int
np_suspend(sys_thread_t *tid)
{
    return thr_suspend(tid->sys_thread);
}


/*
 * Resume a suspended thread.  Used to implement java.lang.Thread.resume(),
 * which is deprecated.
 */
int
np_continue(sys_thread_t *tid)
{
    return thr_continue(tid->sys_thread);
}

/*
 * If there is any initialization is required by the non-POSIX parts.
 */
void np_initialize_thread(sys_thread_t *tid)
{
    return;
}


/*
 * Get the stack start address, and max stack size for the current thread.
 */
int
np_stackinfo(void **addr, long *size)
{
    stack_t stkseg;

    if (thr_stksegment(&stkseg) == 0) {
        *addr = (void *)(stkseg.ss_sp);
        if (thr_main()) {
            struct rlimit r;
            getrlimit(RLIMIT_STACK, &r);
            *size = (long)r.rlim_cur;
        } else {
            *size = (long)(stkseg.ss_size);
        }
        return SYS_OK;
    } else {
        return SYS_ERR; /* thr_stksegment failed. */
    }
}

/*
 * On Solaris when doing CPU profiling, the threads are bound.
 */
void
np_profiler_init(sys_thread_t *tid)
{
    tid->lwp_id = _lwp_self();
}

int
np_profiler_suspend(sys_thread_t *tid)
{
    return _lwp_suspend(tid->lwp_id);
}

int
np_profiler_continue(sys_thread_t *tid)
{
    return _lwp_continue(tid->lwp_id);
}

bool_t
np_profiler_thread_is_running(sys_thread_t *tid)
{
    unsigned long sum = 0;
    int i;
    prstatus_t lwpstatus;
    int lwpfd;
    int res;

    lwpfd = syscall(SYS_ioctl, procfd, PIOCOPENLWP, &(tid->lwp_id));
    sysAssert(lwpfd >= 0);

 retry:
    res = syscall(SYS_ioctl, lwpfd, PIOCSTATUS, &lwpstatus);
    sysAssert(res >= 0);

    if (!(lwpstatus.pr_flags & PR_STOPPED)) {
        GC_msec_sleep(1);
        goto retry;
    }

    close(lwpfd);

#if   defined(sparc)
    sum += lwpstatus.pr_reg[R_SP];
    sum += lwpstatus.pr_reg[R_PC];

    sum += lwpstatus.pr_reg[R_G1];
    sum += lwpstatus.pr_reg[R_G2];
    sum += lwpstatus.pr_reg[R_G3];
    sum += lwpstatus.pr_reg[R_G4];

    sum += lwpstatus.pr_reg[R_O0];
    sum += lwpstatus.pr_reg[R_O1];
    sum += lwpstatus.pr_reg[R_O2];
    sum += lwpstatus.pr_reg[R_O3];
    sum += lwpstatus.pr_reg[R_O4];
    sum += lwpstatus.pr_reg[R_O5];

    sum += lwpstatus.pr_reg[R_I0];
    sum += lwpstatus.pr_reg[R_I1];
    sum += lwpstatus.pr_reg[R_I2];
    sum += lwpstatus.pr_reg[R_I3];
    sum += lwpstatus.pr_reg[R_I4];
    sum += lwpstatus.pr_reg[R_I5];
    sum += lwpstatus.pr_reg[R_I6];
    sum += lwpstatus.pr_reg[R_I7];

    sum += lwpstatus.pr_reg[R_L0];
    sum += lwpstatus.pr_reg[R_L1];
    sum += lwpstatus.pr_reg[R_L2];
    sum += lwpstatus.pr_reg[R_L3];
    sum += lwpstatus.pr_reg[R_L4];
    sum += lwpstatus.pr_reg[R_L5];
    sum += lwpstatus.pr_reg[R_L6];
    sum += lwpstatus.pr_reg[R_L7];
#elif defined(amd64)
    sum += lwpstatus.pr_reg[REG_RIP];
    sum += lwpstatus.pr_reg[REG_RSP];

    sum += lwpstatus.pr_reg[REG_RAX];
    sum += lwpstatus.pr_reg[REG_RCX];
    sum += lwpstatus.pr_reg[REG_RDX];
    sum += lwpstatus.pr_reg[REG_RBX];
    sum += lwpstatus.pr_reg[REG_RBP];
    sum += lwpstatus.pr_reg[REG_RSI];
    sum += lwpstatus.pr_reg[REG_RDI];

    sum += lwpstatus.pr_reg[REG_R8];
    sum += lwpstatus.pr_reg[REG_R9];
    sum += lwpstatus.pr_reg[REG_R10];
    sum += lwpstatus.pr_reg[REG_R11];
    sum += lwpstatus.pr_reg[REG_R12];
    sum += lwpstatus.pr_reg[REG_R13];
    sum += lwpstatus.pr_reg[REG_R14];
    sum += lwpstatus.pr_reg[REG_R15];
#elif defined(i386)
    sum += lwpstatus.pr_reg[EIP];
    sum += lwpstatus.pr_reg[UESP];

    sum += lwpstatus.pr_reg[EAX];
    sum += lwpstatus.pr_reg[ECX];
    sum += lwpstatus.pr_reg[EDX];
    sum += lwpstatus.pr_reg[EBX];
    sum += lwpstatus.pr_reg[EBP];
    sum += lwpstatus.pr_reg[ESI];
    sum += lwpstatus.pr_reg[EDI];
#endif

    if (tid->last_sum == sum) {
        return FALSE;
    }
    tid->last_sum = sum;

    return TRUE;
}


/*
 * If building for Solaris native threads, open up the /proc file
 * descriptor to be used when doing GC. The open is done at JVM start-up so
 * as to reserve this fd, to prevent GC stall due to exhausted fds. This fd
 * will never be closed, and will alwyas be present.
 */
int
np_initialize()
{
    char procname[32];
    MakeProcName(procname, getpid());
    if ((procfd = open(procname, O_RDONLY, 0)) < 0) {
        VM_CALL(jio_fprintf)(stderr, "Cannot open %s for GC", procname);
        return SYS_ERR;
    }
    return SYS_OK;
}

static void
MakeProcName(register char *procname, register pid_t pid)
{
    register char * s;

    (void) strcpy(procname, "/proc/00000");
    s = procname + strlen(procname);
    while (pid) {
        *--s = pid%10 + '0';
        pid /= 10;
    }
}

/*
 * Suspend all other threads, and record their contexts (register
 * set or stack pointer) into the sys_thread structure, so that a
 * garbage collect can be run.
 */
int
np_single(void)
{
    int ret;

    sysAssert(SYS_QUEUE_LOCKED(sysThreadSelf()));

    stop_lwps();
    ret = SYS_OK;
    return ret;
}

/*
 * Continue threads suspended earlier.  But clear their context
 * recorded in sys_thread structure first.
 */
void
np_multi(void)
{
    sysAssert(SYS_QUEUE_LOCKED(sysThreadSelf()));
    clear_onproc_flags();
    restart_lwps();
}

/* /proc solution to stop and restrt lwps */
/* make sure gc is run as a bound thread */
/* make sure signals are turned off for gc thread */
/* what about new lwps getting created in the meantime? */

#define MAX_LWPS 1024

static prstatus_t Mystatus;
static id_t lwpid_list_buf[MAX_LWPS];
static id_t oldlwpid_list_buf[MAX_LWPS];
static sys_thread_t *onproct_list_buf[MAX_LWPS];
static id_t *lwpid_list = lwpid_list_buf;
static id_t *oldlwpid_list = oldlwpid_list_buf;
static sys_thread_t **onproct_list = onproct_list_buf;
static int lwpid_list_len;
static int oldlwpid_list_len;
static int onproct_ix = 0;
static int gcprio;
static sigset_t gcmask;

static void
clear_onproc_flags()
{
    int i;

    for (i = 0; i < onproct_ix; i++) {
        ((sys_thread_t *)(onproct_list[i]))->onproc = FALSE;
    }
    onproct_ix = 0;
}


/* Sleep for n milliseconds, n < 1000   */
static void
GC_msec_sleep(int n)
{
    struct timespec ts;

    ts.tv_sec = 0;
    ts.tv_nsec = 1000000*n;
    if (syscall(SYS_nanosleep, &ts, 0) < 0) {
        VM_CALL(jio_fprintf)(stderr, "%d\n", errno);
    }
}

/*
 * Assumes stacks grow down from high to low memory. True on sparc and Intel.
 */
#define VALID_SP(sp, bottom, top) \
       (((uintptr_t)(sp)) < ((uintptr_t)(bottom)) && ((uintptr_t)(sp)) > ((uintptr_t)(top)))

static void
record_lwp_regs(prstatus_t lwpstatus)
{
    sys_thread_t *tid;
    int i;
#if   defined(sparc)
    register uintptr_t sp = lwpstatus.pr_reg[R_SP];
#elif defined(amd64)
    register uintptr_t sp = lwpstatus.pr_reg[REG_RSP];
#elif defined(i386)
    register uintptr_t sp = lwpstatus.pr_reg[UESP];
#endif

    tid = ThreadQueue;
    for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
        if (VALID_SP(sp, tid->stack_bottom, tid->stack_top)) {
            long *regs = tid->regs;
            tid->sp = sp;
            /*
             * The code below relies on N_TRACED_REGS being set
             * correctly for each platform.  If you change the
             * number of registers being watched, you should update
             * the define for N_TRACED_REGS
             */
#if   defined(sparc)
            regs[0] = lwpstatus.pr_reg[R_G1];
            regs[1] = lwpstatus.pr_reg[R_G2];
            regs[2] = lwpstatus.pr_reg[R_G3];
            regs[3] = lwpstatus.pr_reg[R_G4];

            regs[4] = lwpstatus.pr_reg[R_O0];
            regs[5] = lwpstatus.pr_reg[R_O1];
            regs[6] = lwpstatus.pr_reg[R_O2];
            regs[7] = lwpstatus.pr_reg[R_O3];
            regs[8] = lwpstatus.pr_reg[R_O4];
            regs[9] = lwpstatus.pr_reg[R_O5];
            regs[10] = lwpstatus.pr_reg[R_O6];
            regs[11] = lwpstatus.pr_reg[R_O7];
#elif defined(amd64)
            regs[0] = lwpstatus.pr_reg[REG_RAX];
            regs[1] = lwpstatus.pr_reg[REG_RCX];
            regs[2] = lwpstatus.pr_reg[REG_RDX];
            regs[3] = lwpstatus.pr_reg[REG_RBX];
            regs[4] = lwpstatus.pr_reg[REG_RBP];
            regs[5] = lwpstatus.pr_reg[REG_RSI];
            regs[6] = lwpstatus.pr_reg[REG_RDI];
            regs[7] = lwpstatus.pr_reg[REG_R8];
            regs[8] = lwpstatus.pr_reg[REG_R9];
            regs[9] = lwpstatus.pr_reg[REG_R10];
            regs[10]= lwpstatus.pr_reg[REG_R11];
            regs[11]= lwpstatus.pr_reg[REG_R12];
            regs[12]= lwpstatus.pr_reg[REG_R13];
            regs[13]= lwpstatus.pr_reg[REG_R14];
            regs[14]= lwpstatus.pr_reg[REG_R15];
#elif defined(i386)
            regs[0] = lwpstatus.pr_reg[EAX];
            regs[1] = lwpstatus.pr_reg[ECX];
            regs[2] = lwpstatus.pr_reg[EDX];
            regs[3] = lwpstatus.pr_reg[EBX];
            regs[4] = lwpstatus.pr_reg[EBP];
            regs[5] = lwpstatus.pr_reg[ESI];
            regs[6] = lwpstatus.pr_reg[EDI];
#endif

            if (tid->onproc != TRUE) {
                tid->onproc = TRUE;
                onproct_list[onproct_ix++] = tid;
            }
            break;
        }
        tid = tid->next;
    }
}

static void
record_thread_regs()
{
    sys_thread_t *tid;
    int i;

    tid = ThreadQueue;
    for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
        if (tid->onproc != TRUE) {
            int i;

            if (tid->sys_thread != 0) {
                /* if thread has already been initialized */
                tid->sp = __gettsp(tid->sys_thread);
            } else {
                /*
                 * thread is still in the process of being initalized.
                 * So GC should not care about this thread. Just
                 * set its sp to 0, and this will force GC to ignore it.
                 */
                tid->sp = 0;
            }

            /*
             * Clear out the registers since they are no longer live
             * and we don't want to garbage collector to think they are.
             */

            for (i = 0; i < N_TRACED_REGS; i++)
                tid->regs[i] = 0;
        }
        tid = tid->next;
    }
}

static void
wait_stopped_lwps(void)
{
    int i, lwpfd;
    prstatus_t lwpstatus;

    for (i = 0; i < (int) Mystatus.pr_nlwp; i++) {
        /* if its  not me */
        if (lwpid_list[i] != _lwp_self()) {

            /* open the lwp and check the status */
            if ((lwpfd = syscall(SYS_ioctl, procfd, PIOCOPENLWP,
                &lwpid_list[i])) < 0) {
#ifdef MY_DEBUG
                VM_CALL(jio_fprintf)(stderr, "lwpid %d was not found in process\n",
                            lwpid_list[i]);
#endif
                continue;
            }
            memset(&lwpstatus, 0, sizeof(lwpstatus));
            while (1) {
                if (syscall(SYS_ioctl,lwpfd, PIOCSTATUS, &lwpstatus)<0) {
                    sysAssert(0);
#ifdef MY_DEBUG
                    VM_CALL(jio_fprintf)(stderr, "PIOCSTATUS failed for lwp %d",
                                lwpid_list[i]);
#endif
                    break;
                }
                if (lwpstatus.pr_flags & PR_STOPPED) {
                    record_lwp_regs(lwpstatus);
                    break;
                }
                GC_msec_sleep(1);
            }

            close (lwpfd);
        } /* end of if-me */
    } /* end of for */
}

static void
suspend_lwps()
{
    int i;
    /* pioopen all the lwps and stop them - except the one I am running on */
    for (i = 0; i < (int) Mystatus.pr_nlwp; i++) {

        /* open and stop the lwp if its not me */
        if (lwpid_list[i] != _lwp_self()) {

            /* PIOCSTOP doesn't work without a writable         */
            /* descriptor.  And that makes the process          */
            /* undebuggable.                                    */
            if (_lwp_suspend(lwpid_list[i]) < 0) {
                        /* Could happen if the lwp exited */
                lwpid_list[i] = _lwp_self();
                continue;
            }
        }
    }
}

static void
print_lwps()
{
#ifdef MY_DEBUG
    /* print all the lwps in the process */
    VM_CALL(jio_fprintf)(stdout, "lwpids ");
    for (i = 0; i < (int) Mystatus.pr_nlwp; i++) {
        if (i == 0) {
            VM_CALL(jio_fprintf)(stdout, "%d", lwpid_list[0]);
        } else if (i != Mystatus.pr_nlwp - 1) {
            VM_CALL(jio_fprintf)(stdout, ", %d", lwpid_list[i]);
        } else {
            VM_CALL(jio_fprintf)(stdout, " and %d", lwpid_list[i]);
        }
    }
#endif
}

/* routine to iteratively stop all lwps */
static void
stop_lwps()
{
    int i;
    sigset_t set;
    boolean_t changed;

    /* mask all signals */
    (void) sigfillset(&set);
    syscall(SYS_sigprocmask, SIG_SETMASK, &set, &gcmask);

    /* run at highest prio so I cannot be preempted */
    thr_getprio(thr_self(), &gcprio);
    thr_setprio(thr_self(), 2147483647);  /* #define INT_MAX 2147483647 */

    oldlwpid_list_len = 0;

    while(1) {
        changed = B_FALSE;

        /* Get the # of lwps in the process */
        memset(&Mystatus, 0, sizeof(Mystatus));
        syscall(SYS_ioctl, procfd, PIOCSTATUS, &Mystatus);

#ifdef MY_DEBUG
        VM_CALL(jio_fprintf)(stdout, "Number of lwps in the process is %d\n",
                    Mystatus.pr_nlwp);
        VM_CALL(jio_fprintf)(stdout, "My lwp id is %d\n", _lwp_self());
#endif
        lwpid_list_len = Mystatus.pr_nlwp;
        if (syscall(SYS_ioctl, procfd, PIOCLWPIDS, lwpid_list) == -1) {
#ifdef MY_DEBUG
            VM_CALL(jio_fprintf)(stderr, "Can't read proc's lwpid list");
#endif
            return;
        }

        print_lwps();

        /* suspend all the lwps */
        suspend_lwps();

        /* make sure all the lwps have actually stopped */
        wait_stopped_lwps();

        /* make sure the list has not changed while you were not looking
           else start all over again */
        if (lwpid_list_len != oldlwpid_list_len) changed = B_TRUE;
        else  {
            for (i=0; i<lwpid_list_len; ++i) {
                if (lwpid_list[i] != oldlwpid_list[i]) {
                    changed = B_TRUE; break;
                }
            }
        }
        if (!changed) break;

        {
            id_t *tmplwpid_list = oldlwpid_list;
            oldlwpid_list = lwpid_list; oldlwpid_list_len = lwpid_list_len;
            lwpid_list = 0; lwpid_list_len = 0;
            lwpid_list = tmplwpid_list;
        }
    }

    /* record regs for threads that were not on LWPs */
    record_thread_regs();

    return;
}


/* Restart all lwps in process.  */
static void
restart_lwps()
{
    int i;

    for (i = 0; i < Mystatus.pr_nlwp; i++) {
        if (lwpid_list[i] == _lwp_self()) continue;
        if (_lwp_continue(lwpid_list[i]) < 0) {
#ifdef MY_DEBUG
            VM_CALL(jio_fprintf)(stderr, "Failed to restart lwp %d\n",lwpid_list[i]);
#endif
        }
    }

    /* restore the old priority of the thread */
    thr_setprio(thr_self(), gcprio);
    /* restore the oldmask */
    syscall(SYS_sigprocmask, SIG_SETMASK, &gcmask, NULL);

    print_lwps();
}