|
0
|
1 /*
|
|
|
2 * Copyright 2002-2004 Sun Microsystems, Inc. All Rights Reserved.
|
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
4 *
|
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
|
7 * published by the Free Software Foundation.
|
|
|
8 *
|
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
13 * accompanied this code).
|
|
|
14 *
|
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
18 *
|
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 package sun.jvm.hotspot.debugger.remote;
|
|
|
26
|
|
|
27 import java.rmi.*;
|
|
|
28 import java.util.*;
|
|
|
29
|
|
|
30 import sun.jvm.hotspot.debugger.*;
|
|
|
31 import sun.jvm.hotspot.debugger.cdbg.*;
|
|
|
32 import sun.jvm.hotspot.debugger.remote.sparc.*;
|
|
|
33 import sun.jvm.hotspot.debugger.remote.x86.*;
|
|
|
34 import sun.jvm.hotspot.debugger.remote.amd64.*;
|
|
|
35
|
|
|
36 /** An implementation of Debugger which wraps a
|
|
|
37 RemoteDebugger, providing remote debugging via RMI.
|
|
|
38 This implementation provides caching of the remote process's
|
|
|
39 address space on the local machine where the user interface is
|
|
|
40 running. */
|
|
|
41
|
|
|
42 public class RemoteDebuggerClient extends DebuggerBase implements JVMDebugger {
|
|
|
43 private RemoteDebugger remoteDebugger;
|
|
|
44 private RemoteThreadFactory threadFactory;
|
|
|
45 private boolean unalignedAccessesOkay = false;
|
|
|
46 private static final int cacheSize = 16 * 1024 * 1024; // 16 MB
|
|
|
47
|
|
|
48 public RemoteDebuggerClient(RemoteDebugger remoteDebugger) throws DebuggerException {
|
|
|
49 super();
|
|
|
50 try {
|
|
|
51 this.remoteDebugger = remoteDebugger;
|
|
|
52 machDesc = remoteDebugger.getMachineDescription();
|
|
|
53 utils = new DebuggerUtilities(machDesc.getAddressSize(), machDesc.isBigEndian());
|
|
|
54 int cacheNumPages;
|
|
|
55 int cachePageSize;
|
|
|
56 String cpu = remoteDebugger.getCPU();
|
|
|
57 // page size. (FIXME: should pick this up from the remoteDebugger.)
|
|
|
58 if (cpu.equals("sparc")) {
|
|
|
59 threadFactory = new RemoteSPARCThreadFactory(this);
|
|
|
60 cachePageSize = 8192;
|
|
|
61 cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);
|
|
|
62 } else if (cpu.equals("x86")) {
|
|
|
63 threadFactory = new RemoteX86ThreadFactory(this);
|
|
|
64 cachePageSize = 4096;
|
|
|
65 cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);
|
|
|
66 unalignedAccessesOkay = true;
|
|
|
67 } else if (cpu.equals("amd64")) {
|
|
|
68 threadFactory = new RemoteAMD64ThreadFactory(this);
|
|
|
69 cachePageSize = 4096;
|
|
|
70 cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);
|
|
|
71 unalignedAccessesOkay = true;
|
|
|
72 } else {
|
|
|
73 throw new DebuggerException("Thread access for CPU architecture " + cpu + " not yet supported");
|
|
|
74 }
|
|
|
75
|
|
|
76 // Cache portion of the remote process's address space.
|
|
|
77 initCache(cachePageSize, cacheNumPages);
|
|
|
78
|
|
|
79 jbooleanSize = remoteDebugger.getJBooleanSize();
|
|
|
80 jbyteSize = remoteDebugger.getJByteSize();
|
|
|
81 jcharSize = remoteDebugger.getJCharSize();
|
|
|
82 jdoubleSize = remoteDebugger.getJDoubleSize();
|
|
|
83 jfloatSize = remoteDebugger.getJFloatSize();
|
|
|
84 jintSize = remoteDebugger.getJIntSize();
|
|
|
85 jlongSize = remoteDebugger.getJLongSize();
|
|
|
86 jshortSize = remoteDebugger.getJShortSize();
|
|
|
87 javaPrimitiveTypesConfigured = true;
|
|
|
88 }
|
|
|
89 catch (RemoteException e) {
|
|
|
90 throw new DebuggerException(e);
|
|
|
91 }
|
|
|
92 }
|
|
|
93
|
|
|
94 public long[] getThreadIntegerRegisterSet(Address addr) {
|
|
|
95 try {
|
|
|
96 return remoteDebugger.getThreadIntegerRegisterSet(getAddressValue(addr), true);
|
|
|
97 }
|
|
|
98 catch (RemoteException e) {
|
|
|
99 throw new DebuggerException(e);
|
|
|
100 }
|
|
|
101 }
|
|
|
102
|
|
|
103 public long[] getThreadIntegerRegisterSet(long id) {
|
|
|
104 try {
|
|
|
105 return remoteDebugger.getThreadIntegerRegisterSet(id, false);
|
|
|
106 }
|
|
|
107 catch (RemoteException e) {
|
|
|
108 throw new DebuggerException(e);
|
|
|
109 }
|
|
|
110 }
|
|
|
111
|
|
|
112 /** Unimplemented in this class (remote remoteDebugger should already be attached) */
|
|
|
113 public boolean hasProcessList() throws DebuggerException {
|
|
|
114 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
115 }
|
|
|
116
|
|
|
117 /** Unimplemented in this class (remote remoteDebugger should already be attached) */
|
|
|
118 public List getProcessList() throws DebuggerException {
|
|
|
119 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
120 }
|
|
|
121
|
|
|
122 /** Unimplemented in this class (remote remoteDebugger should already be attached) */
|
|
|
123 public void attach(int processID) throws DebuggerException {
|
|
|
124 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
125 }
|
|
|
126
|
|
|
127 /** Unimplemented in this class (remote remoteDebugger should already be attached) */
|
|
|
128 public void attach(String executableName, String coreFileName) throws DebuggerException {
|
|
|
129 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
130 }
|
|
|
131
|
|
|
132 /** Unimplemented in this class (remote remoteDebugger can not be detached) */
|
|
|
133 public boolean detach() {
|
|
|
134 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
135 }
|
|
|
136
|
|
|
137 public Address parseAddress(String addressString) throws NumberFormatException {
|
|
|
138 long addr = utils.scanAddress(addressString);
|
|
|
139 if (addr == 0) {
|
|
|
140 return null;
|
|
|
141 }
|
|
|
142 return new RemoteAddress(this, addr);
|
|
|
143 }
|
|
|
144
|
|
|
145 public String getOS() throws DebuggerException {
|
|
|
146 try {
|
|
|
147 return remoteDebugger.getOS();
|
|
|
148 }
|
|
|
149 catch (RemoteException e) {
|
|
|
150 throw new DebuggerException(e);
|
|
|
151 }
|
|
|
152 }
|
|
|
153
|
|
|
154 public String getCPU() {
|
|
|
155 try {
|
|
|
156 return remoteDebugger.getCPU();
|
|
|
157 }
|
|
|
158 catch (RemoteException e) {
|
|
|
159 throw new DebuggerException(e);
|
|
|
160 }
|
|
|
161 }
|
|
|
162
|
|
|
163 public boolean hasConsole() throws DebuggerException {
|
|
|
164 try {
|
|
|
165 return remoteDebugger.hasConsole();
|
|
|
166 } catch (RemoteException e) {
|
|
|
167 throw new DebuggerException(e);
|
|
|
168 }
|
|
|
169 }
|
|
|
170
|
|
|
171 public String consoleExecuteCommand(String cmd) throws DebuggerException {
|
|
|
172 try {
|
|
|
173 return remoteDebugger.consoleExecuteCommand(cmd);
|
|
|
174 }
|
|
|
175 catch (RemoteException e) {
|
|
|
176 throw new DebuggerException(e);
|
|
|
177 }
|
|
|
178 }
|
|
|
179
|
|
|
180 public String getConsolePrompt() throws DebuggerException {
|
|
|
181 try {
|
|
|
182 return remoteDebugger.getConsolePrompt();
|
|
|
183 } catch (RemoteException e) {
|
|
|
184 throw new DebuggerException(e);
|
|
|
185 }
|
|
|
186 }
|
|
|
187
|
|
|
188 public CDebugger getCDebugger() throws DebuggerException {
|
|
|
189 return null;
|
|
|
190 }
|
|
|
191
|
|
|
192 //--------------------------------------------------------------------------------
|
|
|
193 // Implementation of SymbolLookup interface
|
|
|
194
|
|
|
195 public Address lookup(String objectName, String symbol) {
|
|
|
196 try {
|
|
|
197 long addr = remoteDebugger.lookupInProcess(objectName, symbol);
|
|
|
198 if (addr == 0) {
|
|
|
199 return null;
|
|
|
200 }
|
|
|
201 return new RemoteAddress(this, addr);
|
|
|
202 }
|
|
|
203 catch (RemoteException e) {
|
|
|
204 throw new DebuggerException(e);
|
|
|
205 }
|
|
|
206 }
|
|
|
207
|
|
|
208 public OopHandle lookupOop(String objectName, String symbol) {
|
|
|
209 try {
|
|
|
210 long addr = remoteDebugger.lookupInProcess(objectName, symbol);
|
|
|
211 if (addr == 0) {
|
|
|
212 return null;
|
|
|
213 }
|
|
|
214 return new RemoteOopHandle(this, addr);
|
|
|
215 }
|
|
|
216 catch (RemoteException e) {
|
|
|
217 throw new DebuggerException(e);
|
|
|
218 }
|
|
|
219 }
|
|
|
220
|
|
|
221 /** Need to override this to relax alignment checks on x86. */
|
|
|
222 public long readCInteger(long address, long numBytes, boolean isUnsigned)
|
|
|
223 throws UnmappedAddressException, UnalignedAddressException {
|
|
|
224 if (!unalignedAccessesOkay) {
|
|
|
225 utils.checkAlignment(address, numBytes);
|
|
|
226 } else {
|
|
|
227 // Only slightly relaxed semantics -- this is a hack, but is
|
|
|
228 // necessary on x86 where it seems the compiler is
|
|
|
229 // putting some global 64-bit data on 32-bit boundaries
|
|
|
230 if (numBytes == 8) {
|
|
|
231 utils.checkAlignment(address, 4);
|
|
|
232 } else {
|
|
|
233 utils.checkAlignment(address, numBytes);
|
|
|
234 }
|
|
|
235 }
|
|
|
236 byte[] data = readBytes(address, numBytes);
|
|
|
237 return utils.dataToCInteger(data, isUnsigned);
|
|
|
238 }
|
|
|
239
|
|
|
240 // Overridden from DebuggerBase because we need to relax alignment
|
|
|
241 // constraints on x86
|
|
|
242 public long readJLong(long address)
|
|
|
243 throws UnmappedAddressException, UnalignedAddressException {
|
|
|
244 // FIXME: allow this to be configurable. Undesirable to add a
|
|
|
245 // dependency on the runtime package here, though, since this
|
|
|
246 // package should be strictly underneath it.
|
|
|
247 if (unalignedAccessesOkay) {
|
|
|
248 utils.checkAlignment(address, jintSize);
|
|
|
249 } else {
|
|
|
250 utils.checkAlignment(address, jlongSize);
|
|
|
251 }
|
|
|
252 byte[] data = readBytes(address, jlongSize);
|
|
|
253 return utils.dataToJLong(data, jlongSize);
|
|
|
254 }
|
|
|
255
|
|
|
256
|
|
|
257 //--------------------------------------------------------------------------------
|
|
|
258 // Implementation of JVMDebugger interface
|
|
|
259 //
|
|
|
260
|
|
|
261 /** Unimplemented in this class (remote remoteDebugger should already be configured) */
|
|
|
262 public void configureJavaPrimitiveTypeSizes(long jbooleanSize,
|
|
|
263 long jbyteSize,
|
|
|
264 long jcharSize,
|
|
|
265 long jdoubleSize,
|
|
|
266 long jfloatSize,
|
|
|
267 long jintSize,
|
|
|
268 long jlongSize,
|
|
|
269 long jshortSize) {
|
|
|
270 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
271 }
|
|
|
272
|
|
|
273 public void setMachineDescription(MachineDescription machDesc) {
|
|
|
274 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
275 }
|
|
|
276
|
|
|
277 public int getRemoteProcessAddressSize() {
|
|
|
278 throw new DebuggerException("Should not be called on RemoteDebuggerClient");
|
|
|
279 }
|
|
|
280
|
|
|
281 public String addressValueToString(long addr) {
|
|
|
282 return utils.addressValueToString(addr);
|
|
|
283 }
|
|
|
284
|
|
|
285 public long getAddressValue(Address addr) throws DebuggerException {
|
|
|
286 if (addr == null) return 0;
|
|
|
287 return ((RemoteAddress) addr).getValue();
|
|
|
288 }
|
|
|
289
|
|
|
290 public Address newAddress(long value) {
|
|
|
291 if (value == 0) return null;
|
|
|
292 return new RemoteAddress(this, value);
|
|
|
293 }
|
|
|
294
|
|
|
295 RemoteAddress readAddress(long address)
|
|
|
296 throws UnmappedAddressException, UnalignedAddressException {
|
|
|
297 long value = readAddressValue(address);
|
|
|
298 return (value == 0 ? null : new RemoteAddress(this, value));
|
|
|
299 }
|
|
|
300
|
|
|
301 RemoteOopHandle readOopHandle(long address)
|
|
|
302 throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
|
|
|
303 long value = readAddressValue(address);
|
|
|
304 return (value == 0 ? null : new RemoteOopHandle(this, value));
|
|
|
305 }
|
|
|
306
|
|
|
307 boolean areThreadsEqual(Address addr1, Address addr2) {
|
|
|
308 try {
|
|
|
309 return remoteDebugger.areThreadsEqual(getAddressValue(addr1), true,
|
|
|
310 getAddressValue(addr2), true);
|
|
|
311 } catch (RemoteException e) {
|
|
|
312 }
|
|
|
313 return false;
|
|
|
314 }
|
|
|
315
|
|
|
316 boolean areThreadsEqual(long id1, long id2) {
|
|
|
317 try {
|
|
|
318 return remoteDebugger.areThreadsEqual(id1, false, id2, false);
|
|
|
319 } catch (RemoteException e) {
|
|
|
320 }
|
|
|
321 return false;
|
|
|
322 }
|
|
|
323
|
|
|
324 boolean areThreadsEqual(Address addr1, long id2) {
|
|
|
325 try {
|
|
|
326 return remoteDebugger.areThreadsEqual(getAddressValue(addr1), true, id2, false);
|
|
|
327 } catch (RemoteException e) {
|
|
|
328 }
|
|
|
329 return false;
|
|
|
330 }
|
|
|
331
|
|
|
332 boolean areThreadsEqual(long id1, Address addr2) {
|
|
|
333 try {
|
|
|
334 return remoteDebugger.areThreadsEqual(id1, false, getAddressValue(addr2), true);
|
|
|
335 } catch (RemoteException e) {
|
|
|
336 }
|
|
|
337 return false;
|
|
|
338 }
|
|
|
339
|
|
|
340 int getThreadHashCode(Address a) {
|
|
|
341 try {
|
|
|
342 return remoteDebugger.getThreadHashCode(getAddressValue(a), true);
|
|
|
343 } catch (RemoteException e) {
|
|
|
344 }
|
|
|
345 return a.hashCode();
|
|
|
346 }
|
|
|
347
|
|
|
348 int getThreadHashCode(long id) {
|
|
|
349 try {
|
|
|
350 return remoteDebugger.getThreadHashCode(id, false);
|
|
|
351 } catch (RemoteException e) {
|
|
|
352 }
|
|
|
353 return (int) id;
|
|
|
354 }
|
|
|
355
|
|
|
356 public ThreadProxy getThreadForIdentifierAddress(Address addr) {
|
|
|
357 return threadFactory.createThreadWrapper(addr);
|
|
|
358 }
|
|
|
359
|
|
|
360 public ThreadProxy getThreadForThreadId(long id) {
|
|
|
361 return threadFactory.createThreadWrapper(id);
|
|
|
362 }
|
|
|
363
|
|
|
364 public MachineDescription getMachineDescription() throws DebuggerException {
|
|
|
365 return machDesc;
|
|
|
366 }
|
|
|
367
|
|
|
368 /** This reads bytes from the remote process. */
|
|
|
369 public ReadResult readBytesFromProcess(long address, long numBytes) {
|
|
|
370 try {
|
|
|
371 return remoteDebugger.readBytesFromProcess(address, numBytes);
|
|
|
372 }
|
|
|
373 catch (RemoteException e) {
|
|
|
374 throw new DebuggerException(e);
|
|
|
375 }
|
|
|
376 }
|
|
|
377
|
|
|
378 public void writeBytesToProcess(long a, long b, byte[] c) {
|
|
|
379 throw new DebuggerException("Unimplemented!");
|
|
|
380 }
|
|
|
381 }
|
