/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
*
* This program and the accompanying materials are made available under
* the terms of the Common Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/cpl-v10.html
*
* $Id: InstrClassLoader.java,v 1.1.1.1.2.2 2004/07/16 23:32:03 vlad_r Exp $
*/
package com.vladium.emma.rt;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.CodeSource;
import java.security.cert.Certificate;
import java.util.Map;
import com.vladium.logging.Logger;
import com.vladium.util.ByteArrayOStream;
import com.vladium.util.asserts.$assert;
import com.vladium.emma.IAppConstants;
import com.vladium.emma.filter.IInclExclFilter;
// ----------------------------------------------------------------------------
/**
* @author Vlad Roubtsov, (C) 2003
*/
public
final class InstrClassLoader extends URLClassLoader
{
// public: ................................................................
// TODO: proper security [use PrivilegedAction as needed]
// TODO: [see above as well] need to keep track of res URLs to support [path] exclusion patterns
// TODO: improve error handling so it is clear when errors come from buggy instrumentation
public static final String PROPERTY_FORCED_DELEGATION_FILTER = "clsload.forced_delegation_filter";
public static final String PROPERTY_THROUGH_DELEGATION_FILTER = "clsload.through_delegation_filter";
public InstrClassLoader (final ClassLoader parent, final File [] classpath,
final IInclExclFilter forcedDelegationFilter,
final IInclExclFilter throughDelegationFilter,
final IClassLoadHook hook, final Map cache)
throws MalformedURLException
{
// setting ClassLoader.parent to null disables the standard delegation
// behavior in a few places, including URLClassLoader.getResource():
super (filesToURLs (classpath), null);
// TODO: arg validation
m_hook = hook;
m_cache = cache; // can be null
m_forcedDelegationFilter = forcedDelegationFilter;
m_throughDelegationFilter = throughDelegationFilter;
m_parent = parent;
m_bufPool = new PoolEntry [BAOS_POOL_SIZE];
m_log = Logger.getLogger ();
}
/**
* Overrides java.lang.ClassLoader.loadClass() to change the usual parent-child
* delegation rules just enough to be able to 'replace' the parent loader. This
* also has the effect of detecting 'system' classes without doing any class
* name-based matching.
*/
public synchronized final Class loadClass (final String name, final boolean resolve)
throws ClassNotFoundException
{
final boolean trace1 = m_log.atTRACE1 ();
if (trace1) m_log.trace1 ("loadClass", "(" + name + ", " + resolve + "): nest level " + m_nestLevel);
Class c = null;
// first, check if this class has already been defined by this classloader
// instance:
c = findLoadedClass (name);
if (c == null)
{
Class parentsVersion = null;
if (m_parent != null)
{
try
{
parentsVersion = m_parent.loadClass (name); // note: it is important that this does not init the class
if ((parentsVersion.getClassLoader () != m_parent) ||
((m_forcedDelegationFilter == null) || m_forcedDelegationFilter.included (name)))
{
// (a) m_parent itself decided to delegate: use parent's version
// (b) the class was on the forced delegation list: use parent's version
c = parentsVersion;
if (trace1) m_log.trace1 ("loadClass", "using parent's version for [" + name + "]");
}
}
catch (ClassNotFoundException cnfe)
{
// if the class was on the forced delegation list, error out:
if ((m_forcedDelegationFilter == null) || m_forcedDelegationFilter.included (name))
throw cnfe;
}
}
if (c == null)
{
try
{
// either (a) m_parent was null or (b) it could not load 'c'
// or (c) it will define 'c' itself if allowed to. In any
// of these cases I attempt to define my own version:
c = findClass (name);
}
catch (ClassNotFoundException cnfe)
{
// this is a difficult design point unless I resurrect the -lx option
// and document how to use it [which will confuse most users anyway]
// another alternative would be to see if parent's version is included by
// the filter and print a warning; still, it does not help with JAXP etc
if (parentsVersion != null)
{
final boolean delegate = (m_throughDelegationFilter == null) || m_throughDelegationFilter.included (name);
if (delegate)
{
c = parentsVersion;
if (trace1) m_log.trace1 ("loadClass", "[delegation filter] using parent's version for [" + name + "]");
}
else
throw cnfe;
}
else
throw cnfe;
}
}
}
if (c == null) throw new ClassNotFoundException (name);
if (resolve) resolveClass (c); // this never happens in J2SE JVMs
return c;
}
// TODO: remove this in the release build
public final URL getResource (final String name)
{
final boolean trace1 = m_log.atTRACE1 ();
if (trace1) m_log.trace1 ("getResource", "(" + name + "): nest level " + m_nestLevel);
final URL result = super.getResource (name);
if (trace1 && (result != null)) m_log.trace1 ("loadClass", "[" + name + "] found in " + result);
return result;
}
// protected: .............................................................
protected final Class findClass (final String name)
throws ClassNotFoundException
{
final boolean trace1 = m_log.atTRACE1 ();
if (trace1) m_log.trace1 ("findClass", "(" + name + "): nest level " + m_nestLevel);
final boolean useClassCache = (m_cache != null);
final ClassPathCacheEntry entry = useClassCache ? (ClassPathCacheEntry) m_cache.remove (name) : null;
byte [] bytes;
int length;
URL classURL = null;
if (entry != null) // cache hit
{
++ m_cacheHits;
// used cached class def bytes, no need to repeat disk I/O:
try
{
classURL = new URL (entry.m_srcURL);
}
catch (MalformedURLException murle) // this should never happen
{
if ($assert.ENABLED)
{
murle.printStackTrace (System.out);
}
}
PoolEntry buf = null;
try
{
buf = acquirePoolEntry ();
final ByteArrayOStream baos = buf.m_baos; // reset() has been called on this
// the original class definition:
bytes = entry.m_bytes;
length = bytes.length;
if ((m_hook != null) && m_hook.processClassDef (name, bytes, length, baos)) // note: this can overwrite 'bytes'
{
// the instrumented class definition:
bytes = baos.getByteArray ();
length = baos.size ();
if (trace1) m_log.trace1 ("findClass", "defining [cached] instrumented [" + name + "] {" + length + " bytes }");
}
else
{
if (trace1) m_log.trace1 ("findClass", "defining [cached] [" + name + "] {" + length + " bytes }");
}
return defineClass (name, bytes, length, classURL);
}
catch (IOException ioe)
{
throw new ClassNotFoundException (name);
}
finally
{
if (buf != null) releasePoolEntry (buf);
}
}
else // cache miss
{
if (useClassCache) ++ m_cacheMisses;
// .class files are not guaranteed to be loadable as resources;
// but if Sun's code does it...
final String classResource = name.replace ('.', '/') + ".class";
// even thought normal delegation is disabled, this will find bootstrap classes:
classURL = getResource (classResource); // important to hook into URLClassLoader's overload of this so that Class-Path manifest attributes are processed etc
if (trace1 && (classURL != null)) m_log.trace1 ("findClass", "[" + name + "] found in " + classURL);
if (classURL == null)
throw new ClassNotFoundException (name);
else
{
InputStream in = null;
PoolEntry buf = null;
try
{
in = classURL.openStream ();
buf = acquirePoolEntry ();
final ByteArrayOStream baos = buf.m_baos; // reset() has been called on this
readFully (in, baos, buf.m_buf);
in.close (); // don't keep the file handle across reentrant calls
in = null;
// the original class definition:
bytes = baos.getByteArray ();
length = baos.size ();
baos.reset (); // reuse this for processClassDef below
if ((m_hook != null) && m_hook.processClassDef (name, bytes, length, baos)) // note: this can overwrite 'bytes'
{
// the instrumented class definition:
bytes = baos.getByteArray ();
length = baos.size ();
if (trace1) m_log.trace1 ("findClass", "defining instrumented [" + name + "] {" + length + " bytes }");
}
else
{
if (trace1) m_log.trace1 ("findClass", "defining [" + name + "] {" + length + " bytes }");
}
return defineClass (name, bytes, length, classURL);
}
catch (IOException ioe)
{
throw new ClassNotFoundException (name);
}
finally
{
if (buf != null) releasePoolEntry (buf);
if (in != null) try { in.close (); } catch (Exception ignore) {}
}
}
}
}
public void debugDump (final PrintWriter out)
{
if (out != null)
{
out.println (this + ": " + m_cacheHits + " class cache hits, " + m_cacheMisses + " misses");
}
}
// package: ...............................................................
// private: ...............................................................
private static final class PoolEntry
{
PoolEntry (final int baosCapacity, final int bufSize)
{
m_baos = new ByteArrayOStream (baosCapacity);
m_buf = new byte [bufSize];
}
void trim (final int baosCapacity, final int baosMaxCapacity)
{
if (m_baos.capacity () > baosMaxCapacity)
{
m_baos = new ByteArrayOStream (baosCapacity);
}
}
ByteArrayOStream m_baos;
final byte [] m_buf;
} // end of nested class
/*
* 'srcURL' may be null
*/
private Class defineClass (final String className, final byte [] bytes, final int length, final URL srcURL)
{
// support ProtectionDomains with non-null class source URLs:
// [however, disable anything related to sealing or signing]
final CodeSource csrc = new CodeSource (srcURL, (Certificate[])null);
// allow getPackage() to return non-null on the class we are about to
// define (however, don't bother emulating the original manifest info since
// we may be altering manifest content anyway):
final int lastDot = className.lastIndexOf ('.');
if (lastDot >= 0)
{
final String packageName = className.substring (0, lastDot);
final Package pkg = getPackage (packageName);
if (pkg == null)
{
definePackage (packageName,
IAppConstants.APP_NAME, IAppConstants.APP_VERSION, IAppConstants.APP_COPYRIGHT,
IAppConstants.APP_NAME, IAppConstants.APP_VERSION, IAppConstants.APP_COPYRIGHT,
srcURL);
}
}
return defineClass (className, bytes, 0, length, csrc);
}
private static URL [] filesToURLs (final File [] classpath)
throws MalformedURLException
{
if ((classpath == null) || (classpath.length == 0))
return EMPTY_URL_ARRAY;
final URL [] result = new URL [classpath.length];
for (int f = 0; f < result.length ; ++ f)
{
result [f] = classpath [f].toURL (); // note: this does proper dir encoding
}
return result;
}
/**
* Reads the entire contents of a given stream into a flat byte array.
*/
private static void readFully (final InputStream in, final ByteArrayOStream out, final byte [] buf)
throws IOException
{
for (int read; (read = in.read (buf)) >= 0; )
{
out.write (buf, 0, read);
}
}
/*
* not MT-safe; must be called from loadClass() only
*/
private PoolEntry acquirePoolEntry ()
{
PoolEntry result;
if (m_nestLevel >= BAOS_POOL_SIZE)
{
result = new PoolEntry (BAOS_INIT_SIZE, BAOS_INIT_SIZE);
}
else
{
result = m_bufPool [m_nestLevel];
if (result == null)
{
result = new PoolEntry (BAOS_INIT_SIZE, BAOS_INIT_SIZE);
m_bufPool [m_nestLevel] = result;
}
else
{
result.m_baos.reset ();
}
}
++ m_nestLevel;
return result;
}
/*
* not MT-safe; must be called from loadClass() only
*/
private void releasePoolEntry (final PoolEntry buf)
{
if (-- m_nestLevel < BAOS_POOL_SIZE)
{
buf.trim (BAOS_INIT_SIZE, BAOS_MAX_SIZE);
}
}
private final ClassLoader m_parent;
private final IInclExclFilter m_forcedDelegationFilter;
private final IInclExclFilter m_throughDelegationFilter;
private final Map /* classJavaName:String -> ClassPathCacheEntry */ m_cache; // can be null
private final IClassLoadHook m_hook;
private final PoolEntry [] m_bufPool;
private final Logger m_log; // a loader instance is used concurrently but cached its log config at construction time
private int m_nestLevel;
private int m_cacheHits, m_cacheMisses;
private static final int BAOS_INIT_SIZE = 32 * 1024;
private static final int BAOS_MAX_SIZE = 1024 * 1024;
private static final int BAOS_POOL_SIZE = 8;
private static final URL [] EMPTY_URL_ARRAY = new URL [0];
} // end of class
// ----------------------------------------------------------------------------
|
