1 /*
2 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package sun.rmi.transport;
26
27 import java.lang.ref.ReferenceQueue;
28 import java.rmi.NoSuchObjectException;
29 import java.rmi.Remote;
30 import java.rmi.dgc.VMID;
31 import java.rmi.server.ExportException;
32 import java.rmi.server.ObjID;
33 import java.security.AccessController;
34 import java.security.PrivilegedAction;
35 import java.util.HashMap;
36 import java.util.Map;
37 import sun.misc.GC;
38 import sun.rmi.runtime.Log;
39 import sun.rmi.runtime.NewThreadAction;
40 import sun.security.action.GetLongAction;
41
42 /**
43 * Object table shared by all implementors of the Transport interface.
44 * This table maps object ids to remote object targets in this address
45 * space.
46 *
47 * @author Ann Wollrath
48 * @author Peter Jones
49 */
50 public final class ObjectTable {
51
52 /** maximum interval between complete garbage collections of local heap */
53 private final static long gcInterval = // default 1 hour
54 AccessController.doPrivileged(
55 new GetLongAction("sun.rmi.dgc.server.gcInterval", 3600000));
56
57 /**
58 * lock guarding objTable and implTable.
59 * Holders MAY acquire a Target instance's lock or keepAliveLock.
60 */
61 private static final Object tableLock = new Object();
62
63 /** tables mapping to Target, keyed from ObjectEndpoint and impl object */
64 private static final Map<ObjectEndpoint,Target> objTable =
65 new HashMap<>();
66 private static final Map<WeakRef,Target> implTable =
67 new HashMap<>();
68
69 /**
70 * lock guarding keepAliveCount, reaper, and gcLatencyRequest.
71 * Holders may NOT acquire a Target instance's lock or tableLock.
72 */
73 private static final Object keepAliveLock = new Object();
74
75 /** count of non-permanent objects in table or still processing calls */
76 private static int keepAliveCount = 0;
77
78 /** thread to collect unreferenced objects from table */
79 private static Thread reaper = null;
80
81 /** queue notified when weak refs in the table are cleared */
82 static final ReferenceQueue<Object> reapQueue = new ReferenceQueue<>();
83
84 /** handle for GC latency request (for future cancellation) */
85 private static GC.LatencyRequest gcLatencyRequest = null;
86
87 /*
88 * Disallow anyone from creating one of these.
89 */
90 private ObjectTable() {}
91
92 /**
93 * Returns the target associated with the object id.
94 */
95 static Target getTarget(ObjectEndpoint oe) {
96 synchronized (tableLock) {
97 return objTable.get(oe);
98 }
99 }
100
101 /**
102 * Returns the target associated with the remote object
103 */
104 public static Target getTarget(Remote impl) {
105 synchronized (tableLock) {
106 return implTable.get(new WeakRef(impl));
107 }
108 }
109
110 /**
111 * Returns the stub for the remote object <b>obj</b> passed
112 * as a parameter. This operation is only valid <i>after</i>
113 * the object has been exported.
114 *
115 * @return the stub for the remote object, <b>obj</b>.
116 * @exception NoSuchObjectException if the stub for the
117 * remote object could not be found.
118 */
119 public static Remote getStub(Remote impl)
120 throws NoSuchObjectException
121 {
122 Target target = getTarget(impl);
123 if (target == null) {
124 throw new NoSuchObjectException("object not exported");
125 } else {
126 return target.getStub();
127 }
128 }
129
130 /**
131 * Remove the remote object, obj, from the RMI runtime. If
132 * successful, the object can no longer accept incoming RMI calls.
133 * If the force parameter is true, the object is forcibly unexported
134 * even if there are pending calls to the remote object or the
135 * remote object still has calls in progress. If the force
136 * parameter is false, the object is only unexported if there are
137 * no pending or in progress calls to the object.
138 *
139 * @param obj the remote object to be unexported
140 * @param force if true, unexports the object even if there are
141 * pending or in-progress calls; if false, only unexports the object
142 * if there are no pending or in-progress calls
143 * @return true if operation is successful, false otherwise
144 * @exception NoSuchObjectException if the remote object is not
145 * currently exported
146 */
147 public static boolean unexportObject(Remote obj, boolean force)
148 throws java.rmi.NoSuchObjectException
149 {
150 synchronized (tableLock) {
151 Target target = getTarget(obj);
152 if (target == null) {
153 throw new NoSuchObjectException("object not exported");
154 } else {
155 if (target.unexport(force)) {
156 removeTarget(target);
157 return true;
158 } else {
159 return false;
160 }
161 }
162 }
163 }
164
165 /**
166 * Add target to object table. If it is not a permanent entry, then
167 * make sure that reaper thread is running to remove collected entries
168 * and keep VM alive.
169 */
170 static void putTarget(Target target) throws ExportException {
171 ObjectEndpoint oe = target.getObjectEndpoint();
172 WeakRef weakImpl = target.getWeakImpl();
173
174 if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
175 DGCImpl.dgcLog.log(Log.VERBOSE, "add object " + oe);
176 }
177
178 synchronized (tableLock) {
179 /**
180 * Do nothing if impl has already been collected (see 6597112). Check while
181 * holding tableLock to ensure that Reaper cannot process weakImpl in between
182 * null check and put/increment effects.
183 */
184 if (target.getImpl() != null) {
185 if (objTable.containsKey(oe)) {
186 throw new ExportException(
187 "internal error: ObjID already in use");
188 } else if (implTable.containsKey(weakImpl)) {
189 throw new ExportException("object already exported");
190 }
191
192 objTable.put(oe, target);
193 implTable.put(weakImpl, target);
194
195 if (!target.isPermanent()) {
196 incrementKeepAliveCount();
197 }
198 }
199 }
200 }
201
202 /**
203 * Remove target from object table.
204 *
205 * NOTE: This method must only be invoked while synchronized on
206 * the "tableLock" object, because it does not do so itself.
207 */
208 private static void removeTarget(Target target) {
209 // assert Thread.holdsLock(tableLock);
210
211 ObjectEndpoint oe = target.getObjectEndpoint();
212 WeakRef weakImpl = target.getWeakImpl();
213
214 if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
215 DGCImpl.dgcLog.log(Log.VERBOSE, "remove object " + oe);
216 }
217
218 objTable.remove(oe);
219 implTable.remove(weakImpl);
220
221 target.markRemoved(); // handles decrementing keep-alive count
222 }
223
224 /**
225 * Process client VM signalling reference for given ObjID: forward to
226 * corresponding Target entry. If ObjID is not found in table,
227 * no action is taken.
228 */
229 static void referenced(ObjID id, long sequenceNum, VMID vmid) {
230 synchronized (tableLock) {
231 ObjectEndpoint oe =
232 new ObjectEndpoint(id, Transport.currentTransport());
233 Target target = objTable.get(oe);
234 if (target != null) {
235 target.referenced(sequenceNum, vmid);
236 }
237 }
238 }
239
240 /**
241 * Process client VM dropping reference for given ObjID: forward to
242 * corresponding Target entry. If ObjID is not found in table,
243 * no action is taken.
244 */
245 static void unreferenced(ObjID id, long sequenceNum, VMID vmid,
246 boolean strong)
247 {
248 synchronized (tableLock) {
249 ObjectEndpoint oe =
250 new ObjectEndpoint(id, Transport.currentTransport());
251 Target target = objTable.get(oe);
252 if (target != null)
253 target.unreferenced(sequenceNum, vmid, strong);
254 }
255 }
256
257 /**
258 * Increments the "keep-alive count".
259 *
260 * The "keep-alive count" is the number of non-permanent remote objects
261 * that are either in the object table or still have calls in progress.
262 * Therefore, this method should be invoked exactly once for every
263 * non-permanent remote object exported (a remote object must be
264 * exported before it can have any calls in progress).
265 *
266 * The VM is "kept alive" while the keep-alive count is greater than
267 * zero; this is accomplished by keeping a non-daemon thread running.
268 *
269 * Because non-permanent objects are those that can be garbage
270 * collected while exported, and thus those for which the "reaper"
271 * thread operates, the reaper thread also serves as the non-daemon
272 * VM keep-alive thread; a new reaper thread is created if necessary.
273 */
274 static void incrementKeepAliveCount() {
275 synchronized (keepAliveLock) {
276 keepAliveCount++;
277
278 if (reaper == null) {
279 reaper = AccessController.doPrivileged(
280 new NewThreadAction(new Reaper(), "Reaper", false));
281 reaper.start();
282 }
283
284 /*
285 * While there are non-"permanent" objects in the object table,
286 * request a maximum latency for inspecting the entire heap
287 * from the local garbage collector, to place an upper bound
288 * on the time to discover remote objects that have become
289 * unreachable (and thus can be removed from the table).
290 */
291 if (gcLatencyRequest == null) {
292 gcLatencyRequest = GC.requestLatency(gcInterval);
293 }
294 }
295 }
296
297 /**
298 * Decrements the "keep-alive count".
299 *
300 * The "keep-alive count" is the number of non-permanent remote objects
301 * that are either in the object table or still have calls in progress.
302 * Therefore, this method should be invoked exactly once for every
303 * previously-exported non-permanent remote object that both has been
304 * removed from the object table and has no calls still in progress.
305 *
306 * If the keep-alive count is decremented to zero, then the current
307 * reaper thread is terminated to cease keeping the VM alive (and
308 * because there are no more non-permanent remote objects to reap).
309 */
310 static void decrementKeepAliveCount() {
311 synchronized (keepAliveLock) {
312 keepAliveCount--;
313
314 if (keepAliveCount == 0) {
315 if (!(reaper != null)) { throw new AssertionError(); }
316 AccessController.doPrivileged(new PrivilegedAction<Void>() {
317 public Void run() {
318 reaper.interrupt();
319 return null;
320 }
321 });
322 reaper = null;
323
324 /*
325 * If there are no longer any non-permanent objects in the
326 * object table, we are no longer concerned with the latency
327 * of local garbage collection here.
328 */
329 gcLatencyRequest.cancel();
330 gcLatencyRequest = null;
331 }
332 }
333 }
334
335 /**
336 * The Reaper thread waits for notifications that weak references in the
337 * object table have been cleared. When it receives a notification, it
338 * removes the corresponding entry from the table.
339 *
340 * Since the Reaper is created as a non-daemon thread, it also serves
341 * to keep the VM from exiting while there are objects in the table
342 * (other than permanent entries that should neither be reaped nor
343 * keep the VM alive).
344 */
345 private static class Reaper implements Runnable {
346
347 public void run() {
348 try {
349 do {
350 // wait for next cleared weak reference
351 WeakRef weakImpl = (WeakRef) reapQueue.remove();
352
353 synchronized (tableLock) {
354 Target target = implTable.get(weakImpl);
355 if (target != null) {
356 if (!target.isEmpty()) {
357 throw new Error(
358 "object with known references collected");
359 } else if (target.isPermanent()) {
360 throw new Error("permanent object collected");
361 }
362 removeTarget(target);
363 }
364 }
365 } while (!Thread.interrupted());
366 } catch (InterruptedException e) {
367 // pass away if interrupted
368 }
369 }
370 }
371 }