/* * Copyright (c) 1998, 2008, 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. */ package com.sun.tools.jdi; import com.sun.jdi.*;import com.sun.jdi.event.*;import com.sun.jdi.connect.spi.Connection;import com.sun.jdi.event.EventSet; import java.util.*;import java.io.IOException; public class TargetVM implements Runnable {    private Map<String, Packet> waitingQueue = new HashMap<String, Packet>(32,0.75f);    private boolean shouldListen = true;    private List<EventQueue> eventQueues = Collections.synchronizedList(new ArrayList<EventQueue>(2));    private VirtualMachineImpl vm;    private Connection connection;    private Thread readerThread;    private EventController eventController = null;    private boolean eventsHeld = false;     /*     * TO DO: The limit numbers below are somewhat arbitrary and should     * be configurable in the future.     */    static private final int OVERLOADED_QUEUE = 2000;    static private final int UNDERLOADED_QUEUE = 100;     TargetVM(VirtualMachineImpl vm, Connection connection) {        this.vm = vm;        this.connection = connection;        this.readerThread = new Thread(vm.threadGroupForJDI(),                                       this, "JDI Target VM Interface");        this.readerThread.setDaemon(true);    }     void start() {        readerThread.start();    }     private void dumpPacket(Packet packet, boolean sending) {        String direction = sending ? "Sending" : "Receiving";        if (sending) {            vm.printTrace(direction + " Command. id=" + packet.id +                          ", length=" + packet.data.length +                          ", commandSet=" + packet.cmdSet +                          ", command=" + packet.cmd +                          ", flags=" + packet.flags);        } else {            String type = (packet.flags & Packet.Reply) != 0 ?                          "Reply" : "Event";            vm.printTrace(direction + " " + type + ". id=" + packet.id +                          ", length=" + packet.data.length +                          ", errorCode=" + packet.errorCode +                          ", flags=" + packet.flags);        }        StringBuffer line = new StringBuffer(80);        line.append("0000: ");        for (int i = 0; i < packet.data.length; i++) {            if ((i > 0) && (i % 16 == 0)) {                vm.printTrace(line.toString());                line.setLength(0);                line.append(String.valueOf(i));                line.append(": ");                int len = line.length();                for (int j = 0; j < 6 - len; j++) {                    line.insert(0, '0');                }            }            int val = 0xff & packet.data[i];            String str = Integer.toHexString(val);            if (str.length() == 1) {                line.append('0');            }            line.append(str);            line.append(' ');        }        if (line.length() > 6) {            vm.printTrace(line.toString());        }    }     public void run() {        if ((vm.traceFlags & VirtualMachine.TRACE_SENDS) != 0) {            vm.printTrace("Target VM interface thread running");        }        Packet p=null,p2;        String idString;         while(shouldListen) {             boolean done = false;            try {                byte b[] = connection.readPacket();                if (b.length == 0) {                    done = true;                }                p = Packet.fromByteArray(b);            } catch (IOException e) {                done = true;            }             if (done) {                shouldListen = false;                try {                    connection.close();                } catch (IOException ioe) { }                break;            }             if ((vm.traceFlags & VirtualMachineImpl.TRACE_RAW_RECEIVES) != 0)  {                dumpPacket(p, false);            }             if((p.flags & Packet.Reply) == 0) {                // It's a command                handleVMCommand(p);            } else {                /*if(p.errorCode != Packet.ReplyNoError) {                    System.err.println("Packet " + p.id + " returned failure = " + p.errorCode);                }*/                 vm.state().notifyCommandComplete(p.id);                idString = String.valueOf(p.id);                 synchronized(waitingQueue) {                    p2 = waitingQueue.get(idString);                     if (p2 != null)                        waitingQueue.remove(idString);                }                 if(p2 == null) {                    // Whoa! a reply without a sender. Problem.                    // FIX ME! Need to post an error.                     System.err.println("Recieved reply with no sender!");                    continue;                }                p2.errorCode = p.errorCode;                p2.data = p.data;                p2.replied = true;                 synchronized(p2) {                    p2.notify();                }            }        }         // inform the VM mamager that this VM is history        vm.vmManager.disposeVirtualMachine(vm);         // close down all the event queues        // Closing a queue causes a VMDisconnectEvent to        // be put onto the queue.        synchronized(eventQueues) {            Iterator iter = eventQueues.iterator();            while (iter.hasNext()) {                ((EventQueueImpl)iter.next()).close();            }        }         // indirectly throw VMDisconnectedException to        // command requesters.        synchronized(waitingQueue) {            Iterator iter = waitingQueue.values().iterator();            while (iter.hasNext()) {                Packet packet = (Packet)iter.next();                synchronized(packet) {                    packet.notify();                }            }            waitingQueue.clear();        }         if ((vm.traceFlags & VirtualMachine.TRACE_SENDS) != 0) {            vm.printTrace("Target VM interface thread exiting");        }    }     protected void handleVMCommand(Packet p) {        switch (p.cmdSet) {            case JDWP.Event.COMMAND_SET:                handleEventCmdSet(p);                break;             default:                System.err.println("Ignoring cmd " + p.id + "/" +                                   p.cmdSet + "/" + p.cmd + " from the VM");                return;        }    }     /* Events should not be constructed on this thread (the thread     * which reads all data from the transport). This means that the     * packet cannot be converted to real JDI objects as that may     * involve further communications with the back end which would     * deadlock.     *     * Instead the whole packet is passed for lazy eval by a queue     * reading thread.     */    protected void handleEventCmdSet(Packet p) {        EventSet eventSet = new EventSetImpl(vm, p);         if (eventSet != null) {            queueEventSet(eventSet);        }    }     private EventController eventController() {        if (eventController == null) {            eventController = new EventController(vm);        }        return eventController;    }     private synchronized void controlEventFlow(int maxQueueSize) {        if (!eventsHeld && (maxQueueSize > OVERLOADED_QUEUE)) {            eventController().hold();            eventsHeld = true;        } else if (eventsHeld && (maxQueueSize < UNDERLOADED_QUEUE)) {            eventController().release();            eventsHeld = false;        }    }     void notifyDequeueEventSet() {        int maxQueueSize = 0;        synchronized(eventQueues) {            Iterator iter = eventQueues.iterator();            while (iter.hasNext()) {                EventQueueImpl queue = (EventQueueImpl)iter.next();                maxQueueSize = Math.max(maxQueueSize, queue.size());            }        }        controlEventFlow(maxQueueSize);    }     private void queueEventSet(EventSet eventSet) {        int maxQueueSize = 0;         synchronized(eventQueues) {            Iterator iter = eventQueues.iterator();            while (iter.hasNext()) {                EventQueueImpl queue = (EventQueueImpl)iter.next();                queue.enqueue(eventSet);                maxQueueSize = Math.max(maxQueueSize, queue.size());            }        }         controlEventFlow(maxQueueSize);    }     void send(Packet packet) {        String id = String.valueOf(packet.id);         synchronized(waitingQueue) {            waitingQueue.put(id, packet);        }         if ((vm.traceFlags & VirtualMachineImpl.TRACE_RAW_SENDS) != 0) {            dumpPacket(packet, true);        }         try {            connection.writePacket(packet.toByteArray());        } catch (IOException e) {            throw new VMDisconnectedException(e.getMessage());        }    }     void waitForReply(Packet packet) {        synchronized(packet) {            while ((!packet.replied) && shouldListen) {                try { packet.wait(); } catch (InterruptedException e) {;}            }             if (!packet.replied) {                throw new VMDisconnectedException();            }        }    }     void addEventQueue(EventQueueImpl queue) {        if ((vm.traceFlags & VirtualMachine.TRACE_EVENTS) != 0) {            vm.printTrace("New event queue added");        }        eventQueues.add(queue);    }     void stopListening() {        if ((vm.traceFlags & VirtualMachine.TRACE_EVENTS) != 0) {            vm.printTrace("Target VM i/f closing event queues");        }        shouldListen = false;        try {            connection.close();        } catch (IOException ioe) { }    }     static private class EventController extends Thread {        VirtualMachineImpl vm;        int controlRequest = 0;         EventController(VirtualMachineImpl vm) {            super(vm.threadGroupForJDI(), "JDI Event Control Thread");            this.vm = vm;            setDaemon(true);            setPriority((MAX_PRIORITY + NORM_PRIORITY)/2);            super.start();        }         synchronized void hold() {            controlRequest++;            notifyAll();        }         synchronized void release() {            controlRequest--;            notifyAll();        }         public void run() {            while(true) {                int currentRequest;                synchronized(this) {                    while (controlRequest == 0) {                        try {wait();} catch (InterruptedException e) {}                    }                    currentRequest = controlRequest;                    controlRequest = 0;                }                try {                    if (currentRequest > 0) {                        JDWP.VirtualMachine.HoldEvents.process(vm);                    } else {                        JDWP.VirtualMachine.ReleaseEvents.process(vm);                    }                } catch (JDWPException e) {                    /*                     * Don't want to terminate the thread, so the                     * stack trace is printed and we continue.                     */                    e.toJDIException().printStackTrace(System.err);                }            }        }    } }