/*
* Copyright (c) 1996, 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 sun.rmi.transport;
import java.rmi.Remote;
import java.rmi.NoSuchObjectException;
import java.rmi.dgc.VMID;
import java.rmi.server.ObjID;
import java.rmi.server.Unreferenced;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.util.*;
import sun.rmi.runtime.Log;
import sun.rmi.runtime.NewThreadAction;
import sun.rmi.server.Dispatcher;
/**
* A target contains information pertaining to a remote object that
* resides in this address space. Targets are located via the
* ObjectTable.
*/
public final class Target {
/** object id for target */
private final ObjID id;
/** flag indicating whether target is subject to collection */
private final boolean permanent;
/** weak reference to remote object implementation */
private final WeakRef weakImpl;
/** dispatcher for remote object */
private volatile Dispatcher disp;
/** stub for remote object */
private final Remote stub;
/** set of clients that hold references to this target */
private final Vector refSet = new Vector();
/** table that maps client endpoints to sequence numbers */
private final Hashtable sequenceTable = new Hashtable(5);
/** access control context in which target was created */
private final AccessControlContext acc;
/** context class loader in which target was created */
private final ClassLoader ccl;
/** number of pending/executing calls */
private int callCount = 0;
/** true if this target has been removed from the object table */
private boolean removed = false;
/**
* the transport through which this target was exported and
* through which remote calls will be allowed
*/
private volatile Transport exportedTransport = null;
/** number to identify next callback thread created here */
private static int nextThreadNum = 0;
/**
* Construct a Target for a remote object "impl" with
* a specific object id.
*
* If "permanent" is true, then the impl is pinned permanently
* (the impl will not be collected via distributed and/or local
* GC). If "on" is false, than the impl is subject to
* collection. Permanent objects do not keep a server from
* exiting.
*/
public Target(Remote impl, Dispatcher disp, Remote stub, ObjID id,
boolean permanent)
{
this.weakImpl = new WeakRef(impl, ObjectTable.reapQueue);
this.disp = disp;
this.stub = stub;
this.id = id;
this.acc = AccessController.getContext();
/*
* Fix for 4149366: so that downloaded parameter types unmarshalled
* for this impl will be compatible with types known only to the
* impl class's class loader (when it's not identical to the
* exporting thread's context class loader), mark the impl's class
* loader as the loader to use as the context class loader in the
* server's dispatch thread while a call to this impl is being
* processed (unless this exporting thread's context class loader is
* a child of the impl's class loader, such as when a registry is
* exported by an application, in which case this thread's context
* class loader is preferred).
*/
ClassLoader threadContextLoader =
Thread.currentThread().getContextClassLoader();
ClassLoader serverLoader = impl.getClass().getClassLoader();
if (checkLoaderAncestry(threadContextLoader, serverLoader)) {
this.ccl = threadContextLoader;
} else {
this.ccl = serverLoader;
}
this.permanent = permanent;
if (permanent) {
pinImpl();
}
}
/**
* Return true if the first class loader is a child of (or identical
* to) the second class loader. Either loader may be "null", which is
* considered to be the parent of any non-null class loader.
*
* (utility method added for the 1.2beta4 fix for 4149366)
*/
private static boolean checkLoaderAncestry(ClassLoader child,
ClassLoader ancestor)
{
if (ancestor == null) {
return true;
} else if (child == null) {
return false;
} else {
for (ClassLoader parent = child;
parent != null;
parent = parent.getParent())
{
if (parent == ancestor) {
return true;
}
}
return false;
}
}
/** Get the stub (proxy) object for this target
*/
public Remote getStub() {
return stub;
}
/**
* Returns the object endpoint for the target.
*/
ObjectEndpoint getObjectEndpoint() {
return new ObjectEndpoint(id, exportedTransport);
}
/**
* Get the weak reference for the Impl of this target.
*/
WeakRef getWeakImpl() {
return weakImpl;
}
/**
* Returns the dispatcher for this remote object target.
*/
Dispatcher getDispatcher() {
return disp;
}
AccessControlContext getAccessControlContext() {
return acc;
}
ClassLoader getContextClassLoader() {
return ccl;
}
/**
* Get the impl for this target.
* Note: this may return null if the impl has been garbage collected.
* (currently, there is no need to make this method public)
*/
Remote getImpl() {
return (Remote)weakImpl.get();
}
/**
* Returns true if the target is permanent.
*/
boolean isPermanent() {
return permanent;
}
/**
* Pin impl in target. Pin the WeakRef object so it holds a strong
* reference to the object to it will not be garbage collected locally.
* This way there is a single object responsible for the weak ref
* mechanism.
*/
synchronized void pinImpl() {
weakImpl.pin();
}
/**
* Unpin impl in target. Weaken the reference to impl so that it
* can be garbage collected locally. But only if there the refSet
* is empty. All of the weak/strong handling is in WeakRef
*/
synchronized void unpinImpl() {
/* only unpin if:
* a) impl is not permanent, and
* b) impl is not already unpinned, and
* c) there are no external references (outside this
* address space) for the impl
*/
if (!permanent && refSet.isEmpty()) {
weakImpl.unpin();
}
}
/**
* Enable the transport through which remote calls to this target
* are allowed to be set if it has not already been set.
*/
void setExportedTransport(Transport exportedTransport) {
if (this.exportedTransport == null) {
this.exportedTransport = exportedTransport;
}
}
/**
* Add an endpoint to the remembered set. Also adds a notifier
* to call back if the address space associated with the endpoint
* dies.
*/
synchronized void referenced(long sequenceNum, VMID vmid) {
// check sequence number for vmid
SequenceEntry entry = (SequenceEntry) sequenceTable.get(vmid);
if (entry == null) {
sequenceTable.put(vmid, new SequenceEntry(sequenceNum));
} else if (entry.sequenceNum < sequenceNum) {
entry.update(sequenceNum);
} else {
// late dirty call; ignore.
return;
}
if (!refSet.contains(vmid)) {
/*
* A Target must be pinned while its refSet is not empty. It may
* have become unpinned if external LiveRefs only existed in
* serialized form for some period of time, or if a client failed
* to renew its lease due to a transient network failure. So,
* make sure that it is pinned here; this fixes bugid 4069644.
*/
pinImpl();
if (getImpl() == null) // too late if impl was collected
return;
if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
DGCImpl.dgcLog.log(Log.VERBOSE, "add to dirty set: " + vmid);
}
refSet.addElement(vmid);
DGCImpl.getDGCImpl().registerTarget(vmid, this);
}
}
/**
* Remove endpoint from remembered set. If set becomes empty,
* remove server from Transport's object table.
*/
synchronized void unreferenced(long sequenceNum, VMID vmid, boolean strong)
{
// check sequence number for vmid
SequenceEntry entry = (SequenceEntry) sequenceTable.get(vmid);
if (entry == null || entry.sequenceNum > sequenceNum) {
// late clean call; ignore
return;
} else if (strong) {
// strong clean call; retain sequenceNum
entry.retain(sequenceNum);
} else if (entry.keep == false) {
// get rid of sequence number
sequenceTable.remove(vmid);
}
if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
DGCImpl.dgcLog.log(Log.VERBOSE, "remove from dirty set: " + vmid);
}
refSetRemove(vmid);
}
/**
* Remove endpoint from the reference set.
*/
synchronized private void refSetRemove(VMID vmid) {
// remove notification request
DGCImpl.getDGCImpl().unregisterTarget(vmid, this);
if (refSet.removeElement(vmid) && refSet.isEmpty()) {
// reference set is empty, so server can be garbage collected.
// remove object from table.
if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
DGCImpl.dgcLog.log(Log.VERBOSE,
"reference set is empty: target = " + this);
}
/*
* If the remote object implements the Unreferenced interface,
* invoke its unreferenced callback in a separate thread.
*/
Remote obj = getImpl();
if (obj instanceof Unreferenced) {
final Unreferenced unrefObj = (Unreferenced) obj;
final Thread t =
java.security.AccessController.doPrivileged(
new NewThreadAction(new Runnable() {
public void run() {
unrefObj.unreferenced();
}
}, "Unreferenced-" + nextThreadNum++, false, true));
// REMIND: access to nextThreadNum not synchronized; you care?
/*
* We must manually set the context class loader appropriately
* for threads that may invoke user code (see bugid 4171278).
*/
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
t.setContextClassLoader(ccl);
return null;
}
});
t.start();
}
unpinImpl();
}
}
/**
* Mark this target as not accepting new calls if any of the
* following conditions exist: a) the force parameter is true,
* b) the target's call count is zero, or c) the object is already
* not accepting calls. Returns true if target is marked as not
* accepting new calls; returns false otherwise.
*/
synchronized boolean unexport(boolean force) {
if ((force == true) || (callCount == 0) || (disp == null)) {
disp = null;
/*
* Fix for 4331349: unpin object so that it may be gc'd.
* Also, unregister all vmids referencing this target
* so target can be gc'd.
*/
unpinImpl();
DGCImpl dgc = DGCImpl.getDGCImpl();
Enumeration enum_ = refSet.elements();
while (enum_.hasMoreElements()) {
VMID vmid = (VMID) enum_.nextElement();
dgc.unregisterTarget(vmid, this);
}
return true;
} else {
return false;
}
}
/**
* Mark this target as having been removed from the object table.
*/
synchronized void markRemoved() {
if (!(!removed)) { throw new AssertionError(); }
removed = true;
if (!permanent && callCount == 0) {
ObjectTable.decrementKeepAliveCount();
}
if (exportedTransport != null) {
exportedTransport.targetUnexported();
}
}
/**
* Increment call count.
*/
synchronized void incrementCallCount() throws NoSuchObjectException {
if (disp != null) {
callCount ++;
} else {
throw new NoSuchObjectException("object not accepting new calls");
}
}
/**
* Decrement call count.
*/
synchronized void decrementCallCount() {
if (--callCount < 0) {
throw new Error("internal error: call count less than zero");
}
/*
* The "keep-alive count" is the number of non-permanent remote
* objects that are either in the object table or still have calls
* in progress. Therefore, this state change may affect the
* keep-alive count: if this target is for a non-permanent remote
* object that has been removed from the object table and now has a
* call count of zero, it needs to be decremented.
*/
if (!permanent && removed && callCount == 0) {
ObjectTable.decrementKeepAliveCount();
}
}
/**
* Returns true if remembered set is empty; otherwise returns
* false
*/
boolean isEmpty() {
return refSet.isEmpty();
}
/**
* This method is called if the address space associated with the
* vmid dies. In that case, the vmid should be removed
* from the reference set.
*/
synchronized public void vmidDead(VMID vmid) {
if (DGCImpl.dgcLog.isLoggable(Log.BRIEF)) {
DGCImpl.dgcLog.log(Log.BRIEF, "removing endpoint " +
vmid + " from reference set");
}
sequenceTable.remove(vmid);
refSetRemove(vmid);
}
}
class SequenceEntry {
long sequenceNum;
boolean keep;
SequenceEntry(long sequenceNum) {
this.sequenceNum = sequenceNum;
keep = false;
}
void retain(long sequenceNum) {
this.sequenceNum = sequenceNum;
keep = true;
}
void update(long sequenceNum) {
this.sequenceNum = sequenceNum;
}
}