1 /*
2 * Copyright (c) 2016, 2018, 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
26 package jdk.jfr.internal;
27
28 import java.security.AccessControlContext;
29 import java.security.AccessController;
30 import java.security.PrivilegedAction;
31 import java.util.ArrayList;
32 import java.util.Collection;
33 import java.util.List;
34 import java.util.Objects;
35 import java.util.concurrent.CopyOnWriteArrayList;
36 import java.util.function.Predicate;
37
38 public final class RequestEngine {
39
40 private final static JVM jvm = JVM.getJVM();
41
42 final static class RequestHook {
43 private final Runnable hook;
44 private final PlatformEventType type;
45 private final AccessControlContext accessControllerContext;
46 private long delta;
47
48 // Java events
49 private RequestHook(AccessControlContext acc, PlatformEventType eventType, Runnable hook) {
50 this.hook = hook;
51 this.type = eventType;
52 this.accessControllerContext = acc;
53 }
54
55 // native events
56 RequestHook(PlatformEventType eventType) {
57 this(null, eventType, null);
58 }
59
60 private void execute() {
61 try {
62 if (accessControllerContext == null) { // native
63 jvm.emitEvent(type.getId(), JVM.counterTime(), 0);
64 Logger.log(LogTag.JFR_SYSTEM_EVENT, LogLevel.DEBUG, ()-> "Executed periodic hook for " + type.getLogName());
65 } else {
66 executeSecure();
67 }
68 } catch (Throwable e) {
69 // Prevent malicious user to propagate exception callback in the wrong context
70 Logger.log(LogTag.JFR_SYSTEM_EVENT, LogLevel.WARN, "Exception occured during execution of period hook for " + type.getLogName());
71 }
72 }
73
74 private void executeSecure() {
75 AccessController.doPrivileged(new PrivilegedAction<Void>() {
76 @Override
77 public Void run() {
78 try {
79 hook.run();
80 Logger.log(LogTag.JFR_EVENT, LogLevel.DEBUG, ()-> "Executed periodic hook for " + type.getLogName());
81 } catch (Throwable t) {
82 // Prevent malicious user to propagate exception callback in the wrong context
83 Logger.log(LogTag.JFR_EVENT, LogLevel.WARN, "Exception occured during execution of period hook for " + type.getLogName());
84 }
85 return null;
86 }
87 }, accessControllerContext);
88 }
89 }
90
91 private final static List<RequestHook> entries = new CopyOnWriteArrayList<>();
92 private static long lastTimeMillis;
93
94 // Insertion takes O(2*n), could be O(1) with HashMap, but
95 // thinking is that CopyOnWriteArrayList is faster
96 // to iterate over, which will happen more over time.
97 public static void addHook(AccessControlContext acc, PlatformEventType type, Runnable hook) {
98 Objects.requireNonNull(acc);
99 RequestHook he = new RequestHook(acc, type, hook);
100 for (RequestHook e : entries) {
101 if (e.hook == hook) {
102 throw new IllegalArgumentException("Hook has already been added");
103 }
104 }
105 he.type.setEventHook(true);
106 entries.add(he);
107 logHook("Added", type);
108 }
109
110
111 private static void logHook(String action, PlatformEventType type) {
112 if (type.isJDK() || type.isJVM()) {
113 Logger.log(LogTag.JFR_SYSTEM_EVENT, LogLevel.INFO, action + " periodic hook for " + type.getLogName());
114 } else {
115 Logger.log(LogTag.JFR_EVENT, LogLevel.INFO, action + " periodic hook for " + type.getLogName());
116 }
117 }
118
119 // Takes O(2*n), see addHook.
120 public static boolean removeHook(Runnable hook) {
121 for (RequestHook rh : entries) {
122 if (rh.hook == hook) {
123 entries.remove(rh);
124 rh.type.setEventHook(false);
125 logHook("Removed", rh.type);
126 return true;
127 }
128 }
129 return false;
130 }
131
132 // Only to be used for JVM events. No access control contest
133 // or check if hook already exists
134 static void addHooks(List<RequestHook> newEntries) {
135 List<RequestHook> addEntries = new ArrayList<>();
136 for (RequestHook rh : newEntries) {
137 rh.type.setEventHook(true);
138 addEntries.add(rh);
139 logHook("Added", rh.type);
140 }
141 entries.addAll(newEntries);
142 }
143
144 static void doChunkEnd() {
145 doChunk(x -> x.isEndChunk());
146 }
147
148 static void doChunkBegin() {
149 doChunk(x -> x.isBeginChunk());
150 }
151
152 private static void doChunk(Predicate<PlatformEventType> predicate) {
153 for (RequestHook requestHook : entries) {
154 PlatformEventType s = requestHook.type;
155 if (s.isEnabled() && predicate.test(s)) {
156 requestHook.execute();
157 }
158 }
159 }
160
161 static long doPeriodic() {
162 return run_requests(entries);
163 }
164
165 // code copied from native impl.
166 private static long run_requests(Collection<RequestHook> entries) {
167 long last = lastTimeMillis;
168 // Bug 9000556 - current time millis has rather lame resolution
169 // The use of os::elapsed_counter() is deliberate here, we don't
170 // want it exchanged for os::ft_elapsed_counter().
171 // Keeping direct call os::elapsed_counter() here for reliable
172 // real time values in order to decide when registered requestable
173 // events are due.
174 long now = System.currentTimeMillis();
175 long min = 0;
176 long delta = 0;
177
178 if (last == 0) {
179 last = now;
180 }
181
182 // time from then to now
183 delta = now - last;
184
185 if (delta < 0) {
186 // to handle time adjustments
187 // for example Daylight Savings
188 lastTimeMillis = now;
189 return 0;
190 }
191 for (RequestHook he : entries) {
192 long left = 0;
193 PlatformEventType es = he.type;
194 // Not enabled, skip.
195 if (!es.isEnabled() || es.isEveryChunk()) {
196 continue;
197 }
198 long r_period = es.getPeriod();
199 long r_delta = he.delta;
200
201 // add time elapsed.
202 r_delta += delta;
203
204 // above threshold?
205 if (r_delta >= r_period) {
206 // Bug 9000556 - don't try to compensate
207 // for wait > period
208 r_delta = 0;
209 he.execute();
210 ;
211 }
212
213 // calculate time left
214 left = (r_period - r_delta);
215
216 /**
217 * nothing outside checks that a period is >= 0, so left can end up
218 * negative here. ex. (r_period =(-1)) - (r_delta = 0) if it is,
219 * handle it.
220 */
221 if (left < 0) {
222 left = 0;
223 }
224
225 // assign delta back
226 he.delta = r_delta;
227
228 if (min == 0 || left < min) {
229 min = left;
230 }
231 }
232 lastTimeMillis = now;
233 return min;
234 }
235 }