libjava/classpath/gnu/classpath/jdwp/Jdwp.java

   1 /* Jdwp.java -- Virtual machine to JDWP back-end programming interface
   2    Copyright (C) 2005, 2006 Free Software Foundation
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 terms of your choice, provided that you also meet, for each linked
  32 independent module, the terms and conditions of the license of that
  33 module.  An independent module is a module which is not derived from
  34 or based on this library.  If you modify this library, you may extend
  35 this exception to your version of the library, but you are not
  36 obligated to do so.  If you do not wish to do so, delete this
  37 exception statement from your version. */
  38
  39
  40 package gnu.classpath.jdwp;
  41
  42 import gnu.classpath.jdwp.event.Event;
  43 import gnu.classpath.jdwp.event.EventManager;
  44 import gnu.classpath.jdwp.event.EventRequest;
  45 import gnu.classpath.jdwp.exception.JdwpException;
  46 import gnu.classpath.jdwp.processor.PacketProcessor;
  47 import gnu.classpath.jdwp.transport.ITransport;
  48 import gnu.classpath.jdwp.transport.JdwpConnection;
  49 import gnu.classpath.jdwp.transport.TransportException;
  50 import gnu.classpath.jdwp.transport.TransportFactory;
  51
  52 import java.io.IOException;
  53 import java.security.AccessController;
  54 import java.util.HashMap;
  55
  56 /**
  57  * Main interface from the virtual machine to the JDWP back-end.
  58  *
  59  * @author Keith Seitz (keiths@redhat.com)
  60  */
  61 public class Jdwp
  62   extends Thread
  63 {
  64   // The single instance of the back-end
  65   private static Jdwp _instance = null;
  66
  67   /**
  68    * Are we debugging?
  69    */
  70   public static boolean isDebugging = false;
  71
  72   // Packet processor
  73   private PacketProcessor _packetProcessor;
  74   private Thread _ppThread;
  75
  76   // JDWP configuration properties
  77   private HashMap _properties;
  78
  79   // The suspend property of the configure string
  80   // (-Xrunjdwp:..suspend=<boolean>)
  81   private static final String _PROPERTY_SUSPEND = "suspend";
  82
  83   // Connection to debugger
  84   private JdwpConnection _connection;
  85
  86   // Are we shutting down the current session?
  87   private boolean _shutdown;
  88
  89   // A thread group for the JDWP threads
  90   private ThreadGroup _group;
  91
  92   /**
  93    * constructor
  94    */
  95   public Jdwp ()
  96   {
  97     _shutdown = false;
  98     isDebugging = true;
  99     _instance = this;
 100   }
 101
 102   /**
 103    * Returns the JDWP back-end, creating an instance of it
 104    * if one does not already exist.
 105    */
 106   public static Jdwp getDefault ()
 107   {
 108     return _instance;
 109   }
 110
 111   /**
 112    * Get the thread group used by JDWP threads
 113    *
 114    * @return the thread group
 115    */
 116   public ThreadGroup getJdwpThreadGroup()
 117   {
 118     return _group;
 119   }
 120
 121   /**
 122    * Should the virtual machine suspend on startup?
 123    */
 124   public static boolean suspendOnStartup ()
 125   {
 126     Jdwp jdwp = getDefault ();
 127     if (jdwp != null)
 128       {
 129         String suspend = (String) jdwp._properties.get (_PROPERTY_SUSPEND);
 130         if (suspend != null && suspend.equals ("y"))
 131           return true;
 132       }
 133
 134     return false;
 135   }
 136
 137   /**
 138    * Configures the back-end
 139    *
 140    * @param configArgs  a string of configury options
 141    */
 142   public void configure (String configArgs)
 143   {
 144     _processConfigury (configArgs);
 145   }
 146
 147   // A helper function to initialize the transport layer
 148   private void _doInitialization ()
 149     throws TransportException
 150   {
 151     _group = new ThreadGroup ("JDWP threads");
 152     // initialize transport
 153     ITransport transport = TransportFactory.newInstance (_properties);
 154     _connection = new JdwpConnection (_group, transport);
 155     _connection.initialize ();
 156     _connection.start ();
 157
 158     // Create processor
 159     _packetProcessor = new PacketProcessor (_connection);
 160     _ppThread = new Thread (_group, new Runnable ()
 161       {
 162         public void run ()
 163         {
 164           AccessController.doPrivileged (_packetProcessor);
 165         }
 166       }, "packet processor");
 167     _ppThread.start ();
 168   }
 169
 170   /**
 171    * Shutdown the JDWP back-end
 172    *
 173    * NOTE: This does not quite work properly. See notes in
 174    * run() on this subject (catch of InterruptedException).
 175    */
 176   public void shutdown ()
 177   {
 178     if (!_shutdown)
 179       {
 180         _packetProcessor.shutdown ();
 181         _ppThread.interrupt ();
 182         _connection.shutdown ();
 183         _shutdown = true;
 184         isDebugging = false;
 185
 186         /* FIXME: probably need to check state of user's
 187            program -- if it is suspended, we need to either
 188            resume or kill them. */
 189
 190         interrupt ();
 191       }
 192   }
 193
 194   /**
 195    * Notify the debugger of an event. This method should not
 196    * be called if debugging is not active (but it would not
 197    * cause any harm). Places where event notifications occur
 198    * should check isDebugging before doing anything.
 199    *
 200    * The event is filtered through the event manager before being
 201    * sent.
 202    *
 203    * FIXME: Probably need logic to send multiple events
 204    * @param event the event to report
 205    */
 206   public static void notify (Event event)
 207   {
 208     Jdwp jdwp = getDefault ();
 209     if (jdwp != null)
 210       {
 211         EventManager em = EventManager.getDefault ();
 212         EventRequest request = em.getEventRequest (event);
 213         if (request != null)
 214           {
 215             try
 216               {
 217                 System.out.println ("Jdwp.notify: sending event " + event);
 218                 sendEvent (request, event);
 219                 jdwp._enforceSuspendPolicy (request.getSuspendPolicy ());
 220               }
 221             catch (Exception e)
 222               {
 223                 /* Really not much we can do. For now, just print out
 224                    a warning to the user. */
 225                 System.out.println ("Jdwp.notify: caught exception: " + e);
 226               }
 227           }
 228       }
 229   }
 230
 231   /**
 232    * Sends the event to the debugger.
 233    *
 234    * This method bypasses the event manager's filtering.
 235    *
 236    * @param  request  the debugger request for the event
 237    * @param  event    the event to send
 238    * @throws IOException if a communications failure occurs
 239    */
 240   public static void sendEvent (EventRequest request, Event event)
 241       throws IOException
 242   {
 243     Jdwp jdwp = getDefault ();
 244     if (jdwp != null)
 245       {
 246         // !! May need to implement send queue?
 247         synchronized (jdwp._connection)
 248           {
 249             jdwp._connection.sendEvent (request, event);
 250           }
 251       }
 252   }
 253
 254   // Helper function to enforce suspend policies on event notification
 255   private void _enforceSuspendPolicy (byte suspendPolicy)
 256     throws JdwpException
 257   {
 258     switch (suspendPolicy)
 259       {
 260       case EventRequest.SUSPEND_NONE:
 261         // do nothing
 262         break;
 263
 264       case EventRequest.SUSPEND_THREAD:
 265         VMVirtualMachine.suspendThread (Thread.currentThread ());
 266         break;
 267
 268       case EventRequest.SUSPEND_ALL:
 269         VMVirtualMachine.suspendAllThreads ();
 270         break;
 271       }
 272   }
 273
 274   public void run ()
 275   {
 276     try
 277       {
 278         _doInitialization ();
 279       }
 280     catch (Throwable t)
 281       {
 282         System.out.println ("Exception in JDWP back-end: " + t);
 283         System.exit (1);
 284       }
 285   }
 286
 287   // A helper function to process the configure string "-Xrunjdwp:..."
 288   private void _processConfigury (String configString)
 289   {
 290     // Loop through configuration arguments looking for a
 291     // transport name
 292     _properties = new HashMap ();
 293     String[] options = configString.split (",");
 294     for (int i = 0; i < options.length; ++i)
 295       {
 296         String[] property = options[i].split ("=");
 297         if (property.length == 2)
 298           _properties.put (property[0], property[1]);
 299         // ignore malformed options
 300       }
 301   }
 302 }