[0.3.x] added : targetSystem.setCurrent method ( set the system as a current )

[0.3.x] added : targetProcess.setCurrent method ( set the process as a current )
[0.3.x] added : targetProcess.getModuleByOffset ( return a module object by it's offset )
[0.3.x] added : targetProcess.getModuleByName ( return a module object by it's name )

git-svn-id: https://pykd.svn.codeplex.com/svn@91021 9b283d60-5439-405e-af05-b73fd8c4d996

pykd/pykdver.h

@@ -2,7 +2,7 @@
 #define PYKD_VERSION_MAJOR      0
 #define PYKD_VERSION_MINOR      3
 #define PYKD_VERSION_SUBVERSION 1
-#define PYKD_VERSION_BUILDNO    4
+#define PYKD_VERSION_BUILDNO    5
 
 #define __VER_STR2__(x) #x
 #define __VER_STR1__(x) __VER_STR2__(x)

pykd/pymod.cpp

@@ -605,12 +605,14 @@ BOOST_PYTHON_MODULE( pykd )
 
 
     python::class_<kdlib::TargetSystem, kdlib::TargetSystemPtr, boost::noncopyable>("targetSystem", "Class representing target system", python::no_init)
-        .def("__init__", python::make_constructor(&kdlib::TargetSystem::getCurrent))
+        .def("__init__", python::make_constructor(&TargetSystemAdapter::getCurrent))
-        .def("__init__", python::make_constructor(&kdlib::TargetSystem::getByIndex))
+        .def("__init__", python::make_constructor(&TargetSystemAdapter::getSystem))
         .def("getNumber", TargetSystemAdapter::getNumberSystems,
             "Return number of systems").staticmethod("getNumber")
         .def("getCurrent", TargetSystemAdapter::getCurrent,
             "Return current target system").staticmethod("getCurrent")
+        .def("setCurrent", TargetSystemAdapter::setCurrent,
+            "set system as a current")
         .def("getSystemById", TargetSystemAdapter::getSystemById,
             "Return target system by id").staticmethod("getSystemById")
         .add_property("desc", TargetSystemAdapter::getDescription,
@@ -641,8 +643,8 @@ BOOST_PYTHON_MODULE( pykd )
         ;
 
     python::class_<kdlib::TargetProcess, kdlib::TargetProcessPtr, boost::noncopyable>("targetProcess", "Class representing process in the target system", python::no_init )
-        .def("__init__", python::make_constructor(&kdlib::TargetProcess::getByIndex))
+        .def("__init__", python::make_constructor(&TargetProcessAdapter::getProcess))
-        .def("__init__", python::make_constructor(&kdlib::TargetProcess::getCurrent))
+        .def("__init__", python::make_constructor(&TargetProcessAdapter::getCurrent))
         .def("getNumber", TargetProcessAdapter::getNumberProcesses,
             "Return number of processes" ).staticmethod("getNumber")
         .def("getCurrent", TargetProcessAdapter::getCurrent,
@@ -677,6 +679,12 @@ BOOST_PYTHON_MODULE( pykd )
             "Return number of modules for this process" )
         .def("getModule", TargetProcessAdapter::getModuleByIndex,
             "Return a module object by it's index" )
+        .def("getModuleByOffset", TargetProcessAdapter::getModuleByOffset,
+            "Return a module object by it's offset" )
+        .def("getModuleByName", TargetProcessAdapter::getModuleByName,
+            "Return a module object by it's name" )
+        .def("setCurrent", TargetProcessAdapter::setCurrent,
+            "Set this process as a current")
         .def("threads", TargetProcessAdapter::getThreadList,
             "Return list of threads for the target process")
         .def("breakpoints", TargetProcessAdapter::getBreakpointsList,
@@ -687,8 +695,8 @@ BOOST_PYTHON_MODULE( pykd )
          ;
 
     python::class_<kdlib::TargetThread, kdlib::TargetThreadPtr, boost::noncopyable>("targetThread", "Class representing process in the target system", python::no_init )
-        .def("__init__", python::make_constructor(&kdlib::TargetThread::getByIndex))
+        .def("__init__", python::make_constructor(&TargetThreadAdapter::getThread))
-        .def("__init__", python::make_constructor(&kdlib::TargetThread::getCurrent))
+        .def("__init__", python::make_constructor(&TargetThreadAdapter::getCurrent))
         .def("getNumber", TargetThreadAdapter::getNumberThreads,
             "Return number of threads").staticmethod("getNumber")
         .def("getCurrent", TargetThreadAdapter::getCurrent,

pykd/pyprocess.cpp

@@ -83,9 +83,19 @@ std::wstring TargetProcessAdapter::print(kdlib::TargetProcess& process)
 {
     std::wstringstream sstr;
 
+    
+    if ( !process.isKernelDebugging() )
+    {
         sstr << "Target Process:" << std::endl;
         sstr << "PID: " << std::hex << process.getSystemId() << std::endl;
         sstr << "Name: " << process.getExecutableName() << std::endl;
+    }
+    else
+    {
+        sstr << "Kernel virtual process:" << std::endl;
+        sstr << "Name: " << process.getExecutableName() << std::endl;
+    }
+
     return sstr.str();
 }
 
@@ -113,9 +123,17 @@ std::wstring TargetThreadAdapter::print(kdlib::TargetThread& thread)
 {
     std::wstringstream sstr;
 
+    if ( !thread.isKernelDebugging() )
+    {
         sstr << "Target Thread:" << std::endl;
         sstr << "PID: " << std::hex << thread.getProcess()->getSystemId() << std::endl;
         sstr << "TID: " << std::hex << thread.getSystemId() << std::endl;
+    }
+    else
+    {
+        sstr << "Kernel virtual thread" << std::endl;
+    }
+
     return sstr.str();
 }
 

pykd/pyprocess.h

@@ -33,6 +33,12 @@ struct TargetSystemAdapter {
         return kdlib::TargetSystem::getById(id);
     }
 
+    static void setCurrent(kdlib::TargetSystem& system)
+    {
+        AutoRestorePyState  pystate;
+        system.setCurrent();
+    }
+
     static std::wstring getDescription(kdlib::TargetSystem& system)
     {
         AutoRestorePyState  pystate;
@@ -131,6 +137,12 @@ struct TargetProcessAdapter {
         return kdlib::TargetProcess::getNumber();
     }
 
+    static void setCurrent(kdlib::TargetProcess& process)
+    {   
+        AutoRestorePyState  pystate;
+        return process.setCurrent();
+    }
+
     static kdlib::PROCESS_ID getSystemId(kdlib::TargetProcess& process)
     {
         AutoRestorePyState  pystate;
@@ -221,6 +233,18 @@ struct TargetProcessAdapter {
         return process.getModuleByIndex(index);
     }
 
+    static kdlib::ModulePtr getModuleByOffset(kdlib::TargetProcess& process, kdlib::MEMOFFSET_64 offset)
+    {
+        AutoRestorePyState  pystate;
+        return process.getModuleByOffset(offset);
+    }
+
+    static kdlib::ModulePtr getModuleByName(kdlib::TargetProcess& process, const std::wstring& name)
+    {
+        AutoRestorePyState  pystate;
+        return process.getModuleByName(name);
+    }
+
     static python::list getThreadList(kdlib::TargetProcess& process);
 
     static python::list getBreakpointsList(kdlib::TargetProcess& process);