inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/agent/commandset/virtualmachinecmdset.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "virtualmachinecmdset.h"

namespace inspectorj {
namespace agent {
namespace commandset {

using namespace inspectorj::jdwp;

VirtualMachineCmdSet::VirtualMachineCmdSet(JavaVM *vm, JNIEnv *env, jvmtiEnv *jvmti)
{
    this->vm = vm;
    this->env = env;
    this->jvmti = jvmti;
}

VirtualMachineCmdSet::~VirtualMachineCmdSet()
{
}


void VirtualMachineCmdSet::process(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    int jdwpCmd = static_cast<int>(cmd->getCmd());
    switch (jdwpCmd) {
        case VM_CMD_VERSION : getVersionInfo(cmd, cbk); break;
        case VM_CMD_CLASSES_BY_SIGNATURE : getClassesBySignature(cmd, cbk); break;
        case VM_CMD_ALL_CLASSES : getAllClasses(cmd, cbk); break;
        case VM_CMD_ALL_THREADS : getAllThreads(cmd, cbk); break;
        case VM_CMD_TOP_LEVEL_THREAD_GROUPS : getTopLevelThreadGroups(cmd, cbk); break;
        case VM_CMD_DISPOSE : dispose(cmd, cbk); break;
        case VM_CMD_ID_SIZES : getIdSizes(cmd, cbk); break;
        case VM_CMD_SUSPEND : suspend(cmd, cbk); break;
        case VM_CMD_RESUME : resume(cmd, cbk); break;
        case VM_CMD_EXIT : exit(cmd, cbk); break;
        case VM_CMD_CREATE_STRING : createString(cmd, cbk); break;
        case VM_CMD_CAPABILITIES : capabilities(cmd, cbk); break;
        case VM_CMD_CLASSPATHS : classpaths(cmd, cbk); break;
        case VM_CMD_DISPOSE_OBJECTS : disposeObjects(cmd, cbk); break;
        case VM_CMD_HOLD_EVENTS : holdEvents(cmd, cbk); break;
        case VM_CMD_RELEASE_EVENTS : releaseEvents(cmd, cbk); break;
        case VM_CMD_CAPABILITIES_NEW : newCapabilities(cmd, cbk); break;
        case VM_CMD_REDEFINE_CLASSES : redefineClasses(cmd, cbk); break;
        case VM_CMD_SET_DEFAULT_STRATUM : setDefaultStratum(cmd, cbk); break;
        case VM_CMD_ALL_CLASSES_WITH_GENERIC : getAllClassesWithGeneric(cmd, cbk); break;     
        default : sendNotImplementedReply(cmd, cbk); break;
    }
    

}

void VirtualMachineCmdSet::getVersionInfo(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    JDWPReply *reply = getJDWPReply(cmd);
    QString versionInfo = "Java Debug Wire Protocol - inspectorj implementation.\n";
    
    jvmtiError error;
        
    char* vmNameProperty = "java.vm.name";
    char* vmName = "";
    error = jvmti->GetSystemProperty(vmNameProperty, &vmName);
    QString vmNameString(vmName);
    versionInfo.append(vmNameString);
    versionInfo.append(" - version ");
    if (!error) {
        error = jvmti->Deallocate((unsigned char*)vmName);
        check_jvmti_error(jvmti, error, "[VirtualMachineCmdSet::getVersionInfo] Error: Could not deallocate memory for vmName.\n");
    }
        
    char* javaVersionProperty = "java.vm.version";
    char* javaVersion = "";
    error = jvmti->GetSystemProperty(javaVersionProperty, &javaVersion);
    QString javaVersionString(javaVersion);
    versionInfo.append(javaVersionString);
    versionInfo.append("\n");
    if (!error) {
        error = jvmti->Deallocate((unsigned char*)javaVersion);
        check_jvmti_error(jvmti, error, "[VirtualMachineCmdSet::getVersionInfo] Error: Could not deallocate memory for javaVersion.\n");
    }
    
    *reply << versionInfo;
    jint v1 = 1;
    jint v2 = 0;
    *reply << v1;
    *reply << v2;
    *reply << javaVersionString;
    *reply << vmNameString;
    cbk(reply);        
}

void VirtualMachineCmdSet::getClassesBySignature(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::getAllClasses(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    JDWPCommandSet::getClassMap().clear();
    JDWPReply *reply = getJDWPReply(cmd);
    jvmtiError error;
    jint clsNum;
    jclass *classes;
    error = jvmti->GetLoadedClasses(&clsNum, &classes);
    check_jvmti_error(jvmti, error, "Error getting Loaded Classes\n");
    qint64 referenceId = 0;
    // store the number of loaded classes
    *reply << clsNum;
    for (int i = 0; i < clsNum; i++) {
        
        // Store all classes in the classMap
        JDWPCommandSet::getClassMap().insert(++referenceId, classes[i]);
        
        // Get the reference type (array |  class | interface)
        jboolean type = 0; 
        jbyte _type;      
        error = jvmti->IsInterface(classes[i], &type);
        
        if (type) {
            jbyte _type = (jbyte) TAG_TYPE_INTERFACE;
            *reply << _type;
        } else {
            error = jvmti->IsArrayClass(classes[i], &type);
            if (type) { 
                _type = (jbyte)TAG_TYPE_ARRAY;
                *reply << _type;
            } else {
                _type = (jbyte) TAG_TYPE_CLASS;
                *reply << _type;
            }  
        }
        
        // store the referenceTypeId
        *reply << referenceId;
        
        
        // Get the jni signature of the class
        char* jniSignature;
        char* genericSignature;
        
        error = jvmti->GetClassSignature(classes[i], &jniSignature, &genericSignature);
        check_jvmti_error(jvmti, error, "Error getting class signature\n");
        QString signature(jniSignature);
        *reply << signature;
        error = jvmti->Deallocate((unsigned char*)jniSignature);
        error = jvmti->Deallocate((unsigned char*)genericSignature);
        
        // Get the class status
        jint status;
        error = jvmti->GetClassStatus(classes[i], &status);
        check_jvmti_error(jvmti, error, "Error getting class status\n");
        *reply << status;
    }
    error = jvmti->Deallocate((unsigned char*)classes);
    check_jvmti_error(jvmti, error, "Error Deallocating classes\n");
    cbk(reply);       
}

void VirtualMachineCmdSet::getAllThreads(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::getTopLevelThreadGroups(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::dispose(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::getIdSizes(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    // send id sizes
    JDWPReply *reply = getJDWPReply(cmd);
    
    qint32 size_four = 4;
    qint32 size_eight = 8;
    
    // field id size
    *reply << size_four;
    
    // method id size
    *reply << size_four;
    
    // object id size
    *reply << size_eight;
    
    // reference type id size
    *reply << size_eight;
    
    // frame id size
    *reply << size_eight;
    
    cbk(reply);
}

void VirtualMachineCmdSet::suspend(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::resume(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::exit(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::createString(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::capabilities(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::classpaths(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::disposeObjects(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::holdEvents(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::releaseEvents(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::newCapabilities(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::redefineClasses(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::setDefaultStratum(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

void VirtualMachineCmdSet::getAllClassesWithGeneric(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    sendNotImplementedReply(cmd, cbk);
}

} // end namespace commandset
} // end namespace agent
} // end namespace inspectorj

---