jdk

1
/*
2
 * Copyright (c) 2018, 2024, 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.
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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 *
23
 */
24

25
#include "precompiled.hpp"
26
#include "classfile/vmSymbols.hpp"
27
#include "gc/shared/barrierSetNMethod.hpp"
28
#include "oops/method.inline.hpp"
29
#include "runtime/continuation.hpp"
30
#include "runtime/continuationEntry.inline.hpp"
31
#include "runtime/continuationHelper.inline.hpp"
32
#include "runtime/continuationJavaClasses.inline.hpp"
33
#include "runtime/continuationWrapper.inline.hpp"
34
#include "runtime/interfaceSupport.inline.hpp"
35
#include "runtime/javaThread.inline.hpp"
36
#include "runtime/osThread.hpp"
37
#include "runtime/vframe.inline.hpp"
38
#include "runtime/vframe_hp.hpp"
39

40
// defined in continuationFreezeThaw.cpp
41
extern "C" jint JNICALL CONT_isPinned0(JNIEnv* env, jobject cont_scope);
42

43
JVM_ENTRY(void, CONT_pin(JNIEnv* env, jclass cls)) {
44
  if (!Continuation::pin(JavaThread::thread_from_jni_environment(env))) {
45
     THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "pin overflow");
46
  }
47
}
48
JVM_END
49

50
JVM_ENTRY(void, CONT_unpin(JNIEnv* env, jclass cls)) {
51
  if (!Continuation::unpin(JavaThread::thread_from_jni_environment(env))) {
52
     THROW_MSG(vmSymbols::java_lang_IllegalStateException(), "pin underflow");
53
  }
54
}
55
JVM_END
56

57
#ifndef PRODUCT
58
static jlong java_tid(JavaThread* thread) {
59
  return java_lang_Thread::thread_id(thread->threadObj());
60
}
61
#endif
62

63
ContinuationEntry* Continuation::get_continuation_entry_for_continuation(JavaThread* thread, oop continuation) {
64
  if (thread == nullptr || continuation == nullptr) {
65
    return nullptr;
66
  }
67

68
  for (ContinuationEntry* entry = thread->last_continuation(); entry != nullptr; entry = entry->parent()) {
69
    if (continuation == entry->cont_oop(thread)) {
70
      return entry;
71
    }
72
  }
73
  return nullptr;
74
}
75

76
static bool is_on_stack(JavaThread* thread, const ContinuationEntry* entry) {
77
  if (entry == nullptr) {
78
    return false;
79
  }
80

81
  assert(thread->is_in_full_stack((address)entry), "");
82
  return true;
83
  // return false if called when transitioning to Java on return from freeze
84
  // return !thread->has_last_Java_frame() || thread->last_Java_sp() < cont->entry_sp();
85
}
86

87
bool Continuation::is_continuation_mounted(JavaThread* thread, oop continuation) {
88
  return is_on_stack(thread, get_continuation_entry_for_continuation(thread, continuation));
89
}
90

91
// When walking the virtual stack, this method returns true
92
// iff the frame is a thawed continuation frame whose
93
// caller is still frozen on the h-stack.
94
// The continuation object can be extracted from the thread.
95
bool Continuation::is_cont_barrier_frame(const frame& f) {
96
  assert(f.is_interpreted_frame() || f.cb() != nullptr, "");
97
  if (!Continuations::enabled()) return false;
98
  return is_return_barrier_entry(f.is_interpreted_frame() ? ContinuationHelper::InterpretedFrame::return_pc(f)
99
                                                          : ContinuationHelper::CompiledFrame::return_pc(f));
100
}
101

102
bool Continuation::is_return_barrier_entry(const address pc) {
103
  if (!Continuations::enabled()) return false;
104
  return pc == StubRoutines::cont_returnBarrier();
105
}
106

107
bool Continuation::is_continuation_enterSpecial(const frame& f) {
108
  if (f.cb() == nullptr || !f.cb()->is_nmethod()) {
109
    return false;
110
  }
111
  Method* m = f.cb()->as_nmethod()->method();
112
  return (m != nullptr && m->is_continuation_enter_intrinsic());
113
}
114

115
bool Continuation::is_continuation_entry_frame(const frame& f, const RegisterMap *map) {
116
  // we can do this because the entry frame is never inlined
117
  Method* m = (map != nullptr && map->in_cont() && f.is_interpreted_frame())
118
                  ? map->stack_chunk()->interpreter_frame_method(f)
119
                  : ContinuationHelper::Frame::frame_method(f);
120
  return m != nullptr && m->intrinsic_id() == vmIntrinsics::_Continuation_enter;
121
}
122

123
// The parameter `sp` should be the actual sp and not the unextended sp because at
124
// least on PPC64 unextended_sp < sp is possible as interpreted frames are trimmed
125
// to the actual size of the expression stack before calls. The problem there is
126
// that even unextended_sp < entry_sp < sp is possible for an interpreted frame.
127
static inline bool is_sp_in_continuation(const ContinuationEntry* entry, intptr_t* const sp) {
128
  // entry_sp() returns the unextended_sp which is always greater or equal to the actual sp
129
  return entry->entry_sp() > sp;
130
}
131

132
bool Continuation::is_frame_in_continuation(const ContinuationEntry* entry, const frame& f) {
133
  return is_sp_in_continuation(entry, f.sp());
134
}
135

136
ContinuationEntry* Continuation::get_continuation_entry_for_sp(JavaThread* thread, intptr_t* const sp) {
137
  assert(thread != nullptr, "");
138
  ContinuationEntry* entry = thread->last_continuation();
139
  while (entry != nullptr && !is_sp_in_continuation(entry, sp)) {
140
    entry = entry->parent();
141
  }
142
  return entry;
143
}
144

145
ContinuationEntry* Continuation::get_continuation_entry_for_entry_frame(JavaThread* thread, const frame& f) {
146
  assert(is_continuation_enterSpecial(f), "");
147
  ContinuationEntry* entry = (ContinuationEntry*)f.unextended_sp();
148
  assert(entry == get_continuation_entry_for_sp(thread, f.sp()-2), "mismatched entry");
149
  return entry;
150
}
151

152
bool Continuation::is_frame_in_continuation(JavaThread* thread, const frame& f) {
153
  return f.is_heap_frame() || (get_continuation_entry_for_sp(thread, f.sp()) != nullptr);
154
}
155

156
static frame continuation_top_frame(const ContinuationWrapper& cont, RegisterMap* map) {
157
  stackChunkOop chunk = cont.last_nonempty_chunk();
158
  map->set_stack_chunk(chunk);
159
  return chunk != nullptr ? chunk->top_frame(map) : frame();
160
}
161

162
bool Continuation::has_last_Java_frame(oop continuation, frame* frame, RegisterMap* map) {
163
  ContinuationWrapper cont(continuation);
164
  if (!cont.is_empty()) {
165
    *frame = continuation_top_frame(cont, map);
166
    return true;
167
  } else {
168
    return false;
169
  }
170
}
171

172
frame Continuation::last_frame(oop continuation, RegisterMap *map) {
173
  assert(map != nullptr, "a map must be given");
174
  return continuation_top_frame(ContinuationWrapper(continuation), map);
175
}
176

177
frame Continuation::top_frame(const frame& callee, RegisterMap* map) {
178
  assert(map != nullptr, "");
179
  ContinuationEntry* ce = get_continuation_entry_for_sp(map->thread(), callee.sp());
180
  assert(ce != nullptr, "");
181
  oop continuation = ce->cont_oop(map->thread());
182
  ContinuationWrapper cont(continuation);
183
  return continuation_top_frame(cont, map);
184
}
185

186
javaVFrame* Continuation::last_java_vframe(Handle continuation, RegisterMap *map) {
187
  assert(map != nullptr, "a map must be given");
188
  if (!ContinuationWrapper(continuation()).is_empty()) {
189
    frame f = last_frame(continuation(), map);
190
    for (vframe* vf = vframe::new_vframe(&f, map, nullptr); vf; vf = vf->sender()) {
191
      if (vf->is_java_frame()) {
192
        return javaVFrame::cast(vf);
193
      }
194
    }
195
  }
196
  return nullptr;
197
}
198

199
frame Continuation::continuation_parent_frame(RegisterMap* map) {
200
  assert(map->in_cont(), "");
201
  ContinuationWrapper cont(map);
202
  assert(map->thread() != nullptr || !cont.is_mounted(), "");
203

204
  log_develop_trace(continuations)("continuation_parent_frame");
205
  if (map->update_map()) {
206
    // we need to register the link address for the entry frame
207
    if (cont.entry() != nullptr) {
208
      cont.entry()->update_register_map(map);
209
    } else {
210
      map->clear();
211
    }
212
  }
213

214
  if (!cont.is_mounted()) { // When we're walking an unmounted continuation and reached the end
215
    oop parent = jdk_internal_vm_Continuation::parent(cont.continuation());
216
    stackChunkOop chunk = parent != nullptr ? ContinuationWrapper(parent).last_nonempty_chunk() : nullptr;
217
    if (chunk != nullptr) {
218
      return chunk->top_frame(map);
219
    }
220

221
    map->set_stack_chunk(nullptr);
222
    return frame();
223
  }
224

225
  map->set_stack_chunk(nullptr);
226

227
#if (defined(X86) || defined(AARCH64) || defined(RISCV64) || defined(PPC64)) && !defined(ZERO)
228
  frame sender(cont.entrySP(), cont.entryFP(), cont.entryPC());
229
#else
230
  frame sender = frame();
231
  Unimplemented();
232
#endif
233

234
  return sender;
235
}
236

237
oop Continuation::continuation_scope(oop continuation) {
238
  return continuation != nullptr ? jdk_internal_vm_Continuation::scope(continuation) : nullptr;
239
}
240

241
bool Continuation::is_scope_bottom(oop cont_scope, const frame& f, const RegisterMap* map) {
242
  if (cont_scope == nullptr || !is_continuation_entry_frame(f, map)) {
243
    return false;
244
  }
245

246
  oop continuation;
247
  if (map->in_cont()) {
248
    continuation = map->cont();
249
  } else {
250
    ContinuationEntry* ce = get_continuation_entry_for_sp(map->thread(), f.sp());
251
    if (ce == nullptr) {
252
      return false;
253
    }
254
    continuation = ce->cont_oop(map->thread());
255
  }
256
  if (continuation == nullptr) {
257
    return false;
258
  }
259

260
  oop sc = continuation_scope(continuation);
261
  assert(sc != nullptr, "");
262
  return sc == cont_scope;
263
}
264

265
bool Continuation::is_in_usable_stack(address addr, const RegisterMap* map) {
266
  ContinuationWrapper cont(map);
267
  stackChunkOop chunk = cont.find_chunk_by_address(addr);
268
  return chunk != nullptr ? chunk->is_usable_in_chunk(addr) : false;
269
}
270

271
bool Continuation::pin(JavaThread* current) {
272
  ContinuationEntry* ce = current->last_continuation();
273
  if (ce == nullptr) {
274
    return true; // no continuation mounted
275
  }
276
  return ce->pin();
277
}
278

279
bool Continuation::unpin(JavaThread* current) {
280
  ContinuationEntry* ce = current->last_continuation();
281
  if (ce == nullptr) {
282
    return true; // no continuation mounted
283
  }
284
  return ce->unpin();
285
}
286

287
frame Continuation::continuation_bottom_sender(JavaThread* thread, const frame& callee, intptr_t* sender_sp) {
288
  assert (thread != nullptr, "");
289
  ContinuationEntry* ce = get_continuation_entry_for_sp(thread, callee.sp());
290
  assert(ce != nullptr, "callee.sp(): " INTPTR_FORMAT, p2i(callee.sp()));
291

292
  log_develop_debug(continuations)("continuation_bottom_sender: [" JLONG_FORMAT "] [%d] callee: " INTPTR_FORMAT
293
    " sender_sp: " INTPTR_FORMAT,
294
    java_tid(thread), thread->osthread()->thread_id(), p2i(callee.sp()), p2i(sender_sp));
295

296
  frame entry = ce->to_frame();
297
  if (callee.is_interpreted_frame()) {
298
    entry.set_sp(sender_sp); // sp != unextended_sp
299
  }
300
  return entry;
301
}
302

303
address Continuation::get_top_return_pc_post_barrier(JavaThread* thread, address pc) {
304
  ContinuationEntry* ce;
305
  if (thread != nullptr && is_return_barrier_entry(pc) && (ce = thread->last_continuation()) != nullptr) {
306
    return ce->entry_pc();
307
  }
308
  return pc;
309
}
310

311
void Continuation::set_cont_fastpath_thread_state(JavaThread* thread) {
312
  assert(thread != nullptr, "");
313
  bool fast = !thread->is_interp_only_mode();
314
  thread->set_cont_fastpath_thread_state(fast);
315
}
316

317
void Continuation::notify_deopt(JavaThread* thread, intptr_t* sp) {
318
  ContinuationEntry* entry = thread->last_continuation();
319

320
  if (entry == nullptr) {
321
    return;
322
  }
323

324
  if (is_sp_in_continuation(entry, sp)) {
325
    thread->push_cont_fastpath(sp);
326
    return;
327
  }
328

329
  ContinuationEntry* prev;
330
  do {
331
    prev = entry;
332
    entry = entry->parent();
333
  } while (entry != nullptr && !is_sp_in_continuation(entry, sp));
334

335
  if (entry == nullptr) {
336
    return;
337
  }
338
  assert(is_sp_in_continuation(entry, sp), "");
339
  if (sp > prev->parent_cont_fastpath()) {
340
    prev->set_parent_cont_fastpath(sp);
341
  }
342
}
343

344
#ifndef PRODUCT
345
void Continuation::describe(FrameValues &values) {
346
  JavaThread* thread = JavaThread::active();
347
  if (thread != nullptr) {
348
    for (ContinuationEntry* ce = thread->last_continuation(); ce != nullptr; ce = ce->parent()) {
349
      intptr_t* bottom = ce->entry_sp();
350
      if (bottom != nullptr) {
351
        values.describe(-1, bottom, "continuation entry");
352
      }
353
    }
354
  }
355
}
356
#endif
357

358
#ifdef ASSERT
359
void Continuation::debug_verify_continuation(oop contOop) {
360
  if (!VerifyContinuations) {
361
    return;
362
  }
363
  assert(contOop != nullptr, "");
364
  assert(oopDesc::is_oop(contOop), "");
365
  ContinuationWrapper cont(contOop);
366

367
  assert(oopDesc::is_oop_or_null(cont.tail()), "");
368
  assert(cont.chunk_invariant(), "");
369

370
  bool nonempty_chunk = false;
371
  size_t max_size = 0;
372
  int num_chunks = 0;
373
  int num_frames = 0;
374
  int num_interpreted_frames = 0;
375
  int num_oops = 0;
376

377
  for (stackChunkOop chunk = cont.tail(); chunk != nullptr; chunk = chunk->parent()) {
378
    log_develop_trace(continuations)("debug_verify_continuation chunk %d", num_chunks);
379
    chunk->verify(&max_size, &num_oops, &num_frames, &num_interpreted_frames);
380
    if (!chunk->is_empty()) {
381
      nonempty_chunk = true;
382
    }
383
    num_chunks++;
384
  }
385

386
  const bool is_empty = cont.is_empty();
387
  assert(!nonempty_chunk || !is_empty, "");
388
  assert(is_empty == (!nonempty_chunk && cont.last_frame().is_empty()), "");
389
}
390

391
void Continuation::print(oop continuation) { print_on(tty, continuation); }
392

393
void Continuation::print_on(outputStream* st, oop continuation) {
394
  ContinuationWrapper cont(continuation);
395

396
  st->print_cr("CONTINUATION: " PTR_FORMAT " done: %d",
397
    continuation->identity_hash(), jdk_internal_vm_Continuation::done(continuation));
398
  st->print_cr("CHUNKS:");
399
  for (stackChunkOop chunk = cont.tail(); chunk != nullptr; chunk = chunk->parent()) {
400
    st->print("* ");
401
    chunk->print_on(true, st);
402
  }
403
}
404
#endif // ASSERT
405

406

407
void continuations_init() { Continuations::init(); }
408

409
void Continuations::init() {
410
  Continuation::init();
411
}
412

413
bool Continuations::enabled() {
414
  return VMContinuations;
415
}
416

417
#define CC (char*)  /*cast a literal from (const char*)*/
418
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
419

420
static JNINativeMethod CONT_methods[] = {
421
    {CC"pin",              CC"()V",                                    FN_PTR(CONT_pin)},
422
    {CC"unpin",            CC"()V",                                    FN_PTR(CONT_unpin)},
423
    {CC"isPinned0",        CC"(Ljdk/internal/vm/ContinuationScope;)I", FN_PTR(CONT_isPinned0)},
424
};
425

426
void CONT_RegisterNativeMethods(JNIEnv *env, jclass cls) {
427
    JavaThread* thread = JavaThread::current();
428
    ThreadToNativeFromVM trans(thread);
429
    int status = env->RegisterNatives(cls, CONT_methods, sizeof(CONT_methods)/sizeof(JNINativeMethod));
430
    guarantee(status == JNI_OK, "register jdk.internal.vm.Continuation natives");
431
    guarantee(!env->ExceptionOccurred(), "register jdk.internal.vm.Continuation natives");
432
}
433