/*

 * Copyright (c) 1998, 2006, 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.

 */

#include "util.h"

#include "outStream.h"

#include "eventHandler.h"

#include "threadControl.h"

#include "invoker.h"

/*

 * Event helper thread command commandKinds

 */

#define COMMAND_REPORT_EVENT_COMPOSITE          1

#define COMMAND_REPORT_INVOKE_DONE              2

#define COMMAND_REPORT_VM_INIT                  3

#define COMMAND_SUSPEND_THREAD                  4

/*

 * Event helper thread command singleKinds

 */

#define COMMAND_SINGLE_EVENT                    11

#define COMMAND_SINGLE_UNLOAD                   12

#define COMMAND_SINGLE_FRAME_EVENT              13

typedef struct EventCommandSingle {

    jbyte suspendPolicy; /* NOTE: Must be the first field */

    jint id;

    EventInfo info;

} EventCommandSingle;

typedef struct UnloadCommandSingle {

    char *classSignature;

    jint id;

} UnloadCommandSingle;

typedef struct FrameEventCommandSingle {

    jbyte suspendPolicy; /* NOTE: Must be the first field */

    jint id;

    EventIndex ei;

    jthread thread;

    jclass clazz;

    jmethodID method;

    jlocation location;

    char typeKey;         /* Not used for method entry events */

                          /* If typeKey is 0, then no return value is needed */

    jvalue returnValue;   /* Not used for method entry events */

} FrameEventCommandSingle;

typedef struct CommandSingle {

    jint singleKind;

    union {

        EventCommandSingle eventCommand;

        UnloadCommandSingle unloadCommand;

        FrameEventCommandSingle frameEventCommand;

    } u;

} CommandSingle;

typedef struct ReportInvokeDoneCommand {

    jthread thread;

} ReportInvokeDoneCommand;

typedef struct ReportVMInitCommand {

    jbyte suspendPolicy; /* NOTE: Must be the first field */

    jthread thread;

} ReportVMInitCommand;

typedef struct SuspendThreadCommand {

    jthread thread;

} SuspendThreadCommand;

typedef struct ReportEventCompositeCommand {

    jbyte suspendPolicy; /* NOTE: Must be the first field */

    jint eventCount;

    CommandSingle singleCommand[1]; /* variable length */

} ReportEventCompositeCommand;

typedef struct HelperCommand {

    jint commandKind;

    jboolean done;

    jboolean waiting;

    jbyte sessionID;

    struct HelperCommand *next;

    union {

        /* NOTE: Each of the structs below must have the same first field */

        ReportEventCompositeCommand reportEventComposite;

        ReportInvokeDoneCommand     reportInvokeDone;

        ReportVMInitCommand         reportVMInit;

        SuspendThreadCommand        suspendThread;

    } u;

    /* composite array expand out, put nothing after */

} HelperCommand;

typedef struct {

    HelperCommand *head;

    HelperCommand *tail;

} CommandQueue;

static CommandQueue commandQueue;

static jrawMonitorID commandQueueLock;

static jrawMonitorID commandCompleteLock;

static jrawMonitorID blockCommandLoopLock;

static jint maxQueueSize = 50 * 1024; /* TO DO: Make this configurable */

static jboolean holdEvents;

static jint currentQueueSize = 0;

static jint currentSessionID;

static void saveEventInfoRefs(JNIEnv *env, EventInfo *evinfo);

static void tossEventInfoRefs(JNIEnv *env, EventInfo *evinfo);

static jint

commandSize(HelperCommand *command)

{

    jint size = sizeof(HelperCommand);

    if (command->commandKind == COMMAND_REPORT_EVENT_COMPOSITE) {

        /*

         * One event is accounted for in the Helper Command. If there are

         * more, add to size here.

         */

        /*LINTED*/

        size += ((int)sizeof(CommandSingle) *

                     (command->u.reportEventComposite.eventCount - 1));

    }

    return size;

}

static void

freeCommand(HelperCommand *command)

{

    if ( command == NULL )

        return;

    jvmtiDeallocate(command);

}

static void

enqueueCommand(HelperCommand *command,

               jboolean wait, jboolean reportingVMDeath)

{

    static jboolean vmDeathReported = JNI_FALSE;

    CommandQueue *queue = &commandQueue;

    jint size = commandSize(command);

    command->done = JNI_FALSE;

    command->waiting = wait;

    command->next = NULL;

    debugMonitorEnter(commandQueueLock);

    while (size + currentQueueSize > maxQueueSize) {

        debugMonitorWait(commandQueueLock);

    }

    log_debugee_location("enqueueCommand(): HelperCommand being processed", NULL, NULL, 0);

    if (vmDeathReported) {

        /* send no more events after VMDeath and don't wait */

        wait = JNI_FALSE;

    } else {

        currentQueueSize += size;

        if (queue->head == NULL) {

            queue->head = command;

        } else {

            queue->tail->next = command;

        }

        queue->tail = command;

        if (reportingVMDeath) {

            vmDeathReported = JNI_TRUE;

        }

    }

    debugMonitorNotifyAll(commandQueueLock);

    debugMonitorExit(commandQueueLock);

    if (wait) {

        debugMonitorEnter(commandCompleteLock);

        while (!command->done) {

            log_debugee_location("enqueueCommand(): HelperCommand wait", NULL, NULL, 0);

            debugMonitorWait(commandCompleteLock);

        }

        freeCommand(command);

        debugMonitorExit(commandCompleteLock);

    }

}

static void

completeCommand(HelperCommand *command)

{

    if (command->waiting) {

        debugMonitorEnter(commandCompleteLock);

        command->done = JNI_TRUE;

        log_debugee_location("completeCommand(): HelperCommand done waiting", NULL, NULL, 0);

        debugMonitorNotifyAll(commandCompleteLock);

        debugMonitorExit(commandCompleteLock);

    } else {

        freeCommand(command);

    }

}

static HelperCommand *

dequeueCommand(void)

{

    HelperCommand *command = NULL;

    CommandQueue *queue = &commandQueue;

    jint size;

    debugMonitorEnter(commandQueueLock);

    while (command == NULL) {

        while (holdEvents || (queue->head == NULL)) {

            debugMonitorWait(commandQueueLock);

        }

        JDI_ASSERT(queue->head);

        command = queue->head;

        queue->head = command->next;

        if (queue->tail == command) {

            queue->tail = NULL;

        }

        log_debugee_location("dequeueCommand(): command being dequeued", NULL, NULL, 0);

        size = commandSize(command);

        /*

         * Immediately close out any commands enqueued from a

         * previously attached debugger.

         */

        if (command->sessionID != currentSessionID) {

            log_debugee_location("dequeueCommand(): command session removal", NULL, NULL, 0);

            completeCommand(command);

            command = NULL;

        }

        /*

         * There's room in the queue for more.

         */

        currentQueueSize -= size;

        debugMonitorNotifyAll(commandQueueLock);

    }

    debugMonitorExit(commandQueueLock);

    return command;

}

void eventHelper_holdEvents(void)

{

    debugMonitorEnter(commandQueueLock);

    holdEvents = JNI_TRUE;

    debugMonitorNotifyAll(commandQueueLock);

    debugMonitorExit(commandQueueLock);

}

void eventHelper_releaseEvents(void)

{

    debugMonitorEnter(commandQueueLock);

    holdEvents = JNI_FALSE;

    debugMonitorNotifyAll(commandQueueLock);

    debugMonitorExit(commandQueueLock);

}

static void

writeSingleStepEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);

}

static void

writeBreakpointEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);

}

static void

writeFieldAccessEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    jbyte fieldClassTag;

    fieldClassTag = referenceTypeTag(evinfo->u.field_access.field_clazz);

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);

    (void)outStream_writeByte(out, fieldClassTag);

    (void)outStream_writeObjectRef(env, out, evinfo->u.field_access.field_clazz);

    (void)outStream_writeFieldID(out, evinfo->u.field_access.field);

    (void)outStream_writeObjectTag(env, out, evinfo->object);

    (void)outStream_writeObjectRef(env, out, evinfo->object);

}

static void

writeFieldModificationEvent(JNIEnv *env, PacketOutputStream *out,

                            EventInfo *evinfo)

{

    jbyte fieldClassTag;

    fieldClassTag = referenceTypeTag(evinfo->u.field_modification.field_clazz);

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);

    (void)outStream_writeByte(out, fieldClassTag);

    (void)outStream_writeObjectRef(env, out, evinfo->u.field_modification.field_clazz);

    (void)outStream_writeFieldID(out, evinfo->u.field_modification.field);

    (void)outStream_writeObjectTag(env, out, evinfo->object);

    (void)outStream_writeObjectRef(env, out, evinfo->object);

    (void)outStream_writeValue(env, out, (jbyte)evinfo->u.field_modification.signature_type,

                         evinfo->u.field_modification.new_value);

}

static void

writeExceptionEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);

    (void)outStream_writeObjectTag(env, out, evinfo->object);

    (void)outStream_writeObjectRef(env, out, evinfo->object);

    writeCodeLocation(out, evinfo->u.exception.catch_clazz,

                      evinfo->u.exception.catch_method, evinfo->u.exception.catch_location);

}

static void

writeThreadEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

}

static void

writeMonitorEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    jclass klass;

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    (void)outStream_writeObjectTag(env, out, evinfo->object);

    (void)outStream_writeObjectRef(env, out, evinfo->object);

    if (evinfo->ei == EI_MONITOR_WAIT || evinfo->ei == EI_MONITOR_WAITED) {

        /* clazz of evinfo was set to class of monitor object for monitor wait event class filtering.

         * So get the method class to write location info.

         * See cbMonitorWait() and cbMonitorWaited() function in eventHandler.c.

         */

        klass=getMethodClass(gdata->jvmti, evinfo->method);

        writeCodeLocation(out, klass, evinfo->method, evinfo->location);

        if (evinfo->ei == EI_MONITOR_WAIT) {

            (void)outStream_writeLong(out, evinfo->u.monitor.timeout);

        } else  if (evinfo->ei == EI_MONITOR_WAITED) {

            (void)outStream_writeBoolean(out, evinfo->u.monitor.timed_out);

        }

        /* This runs in a command loop and this thread may not return to java.

         * So we need to delete the local ref created by jvmti GetMethodDeclaringClass.

         */

        JNI_FUNC_PTR(env,DeleteLocalRef)(env, klass);

    } else {

        writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);

    }

}

static void

writeClassEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

    jbyte classTag;

    jint status;

    char *signature = NULL;

    jvmtiError error;

    classTag = referenceTypeTag(evinfo->clazz);

    error = classSignature(evinfo->clazz, &signature, NULL);

    if (error != JVMTI_ERROR_NONE) {

        EXIT_ERROR(error,"signature");

    }

    status = classStatus(evinfo->clazz);

    (void)outStream_writeObjectRef(env, out, evinfo->thread);

    (void)outStream_writeByte(out, classTag);

    (void)outStream_writeObjectRef(env, out, evinfo->clazz);

    (void)outStream_writeString(out, signature);

    (void)outStream_writeInt(out, map2jdwpClassStatus(status));

    jvmtiDeallocate(signature);

}

static void

writeVMDeathEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)

{

}

static void

handleEventCommandSingle(JNIEnv *env, PacketOutputStream *out,

                           EventCommandSingle *command)

{

    EventInfo *evinfo = &command->info;

    (void)outStream_writeByte(out, eventIndex2jdwp(evinfo->ei));

    (void)outStream_writeInt(out, command->id);

    switch (evinfo->ei) {

        case EI_SINGLE_STEP:

            writeSingleStepEvent(env, out, evinfo);

            break;

        case EI_BREAKPOINT:

            writeBreakpointEvent(env, out, evinfo);

            break;

        case EI_FIELD_ACCESS:

            writeFieldAccessEvent(env, out, evinfo);

            break;

        case EI_FIELD_MODIFICATION:

            writeFieldModificationEvent(env, out, evinfo);

            break;

        case EI_EXCEPTION:

            writeExceptionEvent(env, out, evinfo);

            break;

        case EI_THREAD_START:

        case EI_THREAD_END:

            writeThreadEvent(env, out, evinfo);

            break;

        case EI_CLASS_LOAD:

        case EI_CLASS_PREPARE:

            writeClassEvent(env, out, evinfo);

            break;

        case EI_MONITOR_CONTENDED_ENTER:

        case EI_MONITOR_CONTENDED_ENTERED:

        case EI_MONITOR_WAIT:

        case EI_MONITOR_WAITED:

            writeMonitorEvent(env, out, evinfo);

            break;

        case EI_VM_DEATH:

            writeVMDeathEvent(env, out, evinfo);

            break;

        default:

            EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,"unknown event index");

            break;

    }

    tossEventInfoRefs(env, evinfo);

}

static void

handleUnloadCommandSingle(JNIEnv* env, PacketOutputStream *out,

                           UnloadCommandSingle *command)

{

    (void)outStream_writeByte(out, JDWP_EVENT(CLASS_UNLOAD));

    (void)outStream_writeInt(out, command->id);

    (void)outStream_writeString(out, command->classSignature);

    jvmtiDeallocate(command->classSignature);

    command->classSignature = NULL;

}

static void

handleFrameEventCommandSingle(JNIEnv* env, PacketOutputStream *out,

                              FrameEventCommandSingle *command)

{

    if (command->typeKey) {

        (void)outStream_writeByte(out, JDWP_EVENT(METHOD_EXIT_WITH_RETURN_VALUE));

    } else {

        (void)outStream_writeByte(out, eventIndex2jdwp(command->ei));

    }

    (void)outStream_writeInt(out, command->id);

    (void)outStream_writeObjectRef(env, out, command->thread);

    writeCodeLocation(out, command->clazz, command->method, command->location);

    if (command->typeKey) {

        (void)outStream_writeValue(env, out, command->typeKey, command->returnValue);

        if (isObjectTag(command->typeKey) &&

            command->returnValue.l != NULL) {

            tossGlobalRef(env, &(command->returnValue.l));

        }

    }

    tossGlobalRef(env, &(command->thread));

    tossGlobalRef(env, &(command->clazz));

}

static void

suspendWithInvokeEnabled(jbyte policy, jthread thread)

{

    invoker_enableInvokeRequests(thread);

    if (policy == JDWP_SUSPEND_POLICY(ALL)) {

        (void)threadControl_suspendAll();

    } else {

        (void)threadControl_suspendThread(thread, JNI_FALSE);

    }

}

static void

handleReportEventCompositeCommand(JNIEnv *env,

                                  ReportEventCompositeCommand *recc)

{

    PacketOutputStream out;

    jint count = recc->eventCount;

    jint i;

    if (recc->suspendPolicy != JDWP_SUSPEND_POLICY(NONE)) {

        /* must determine thread to interrupt before writing */

        /* since writing destroys it */

        jthread thread = NULL;

        for (i = 0; i < count; i++) {

            CommandSingle *single = &(recc->singleCommand[i]);

            switch (single->singleKind) {

                case COMMAND_SINGLE_EVENT:

                    thread = single->u.eventCommand.info.thread;

                    break;

                case COMMAND_SINGLE_FRAME_EVENT:

                    thread = single->u.frameEventCommand.thread;

                    break;

            }

            if (thread != NULL) {

                break;

            }

        }

        if (thread == NULL) {

            (void)threadControl_suspendAll();

        } else {

            suspendWithInvokeEnabled(recc->suspendPolicy, thread);

        }