src/os_cpu/linux_s390/vm/os_linux_s390.cpp

rev 12483 : 8172049: [s390] Implement "JEP 270: Reserved Stack Areas for Critical Sections".

*** 142,151 ****
--- 142,187 ----
    intptr_t* fp;
    ExtendedPC epc = fetch_frame_from_context(ucVoid, &sp, &fp);
    return frame(sp, epc.pc());
  }
  
+ bool os::Linux::get_frame_at_stack_banging_point(JavaThread* thread, ucontext_t* uc, frame* fr) {
+   address pc = (address) os::Linux::ucontext_get_pc(uc);
+   if (Interpreter::contains(pc)) {
+     // Interpreter performs stack banging after the fixed frame header has
+     // been generated while the compilers perform it before. To maintain
+     // semantic consistency between interpreted and compiled frames, the
+     // method returns the Java sender of the current frame.
+     *fr = os::fetch_frame_from_context(uc);
+     if (!fr->is_first_java_frame()) {
+       assert(fr->safe_for_sender(thread), "Safety check");
+       *fr = fr->java_sender();
+     }
+   } else {
+     // More complex code with compiled code.
+     assert(!Interpreter::contains(pc), "Interpreted methods should have been handled above");
+     CodeBlob* cb = CodeCache::find_blob(pc);
+     if (cb == NULL || !cb->is_nmethod() || cb->is_frame_complete_at(pc)) {
+       // Not sure where the pc points to, fallback to default
+       // stack overflow handling. In compiled code, we bang before
+       // the frame is complete.
+       return false;
+     } else {
+       intptr_t* fp = os::Linux::ucontext_get_fp(uc);
+       intptr_t* sp = os::Linux::ucontext_get_sp(uc);
+       *fr = frame(sp, (address)*sp);
+       if (!fr->is_java_frame()) {
+         assert(fr->safe_for_sender(thread), "Safety check");
+         assert(!fr->is_first_frame(), "Safety check");
+         *fr = fr->java_sender();
+       }
+     }
+   }
+   assert(fr->is_java_frame(), "Safety check");
+   return true;
+ }
+ 
  frame os::get_sender_for_C_frame(frame* fr) {
    if (*fr->sp() == 0) {
      // fr is the last C frame.
      return frame();
    }
*** 277,293 ****
  
        // Check if fault address is within thread stack.
        if (thread->on_local_stack(addr)) {
          // stack overflow
          if (thread->in_stack_yellow_reserved_zone(addr)) {
-           thread->disable_stack_yellow_reserved_zone();
            if (thread->thread_state() == _thread_in_Java) {
              // Throw a stack overflow exception.
              // Guard pages will be reenabled while unwinding the stack.
              stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
            } else {
              // Thread was in the vm or native code. Return and try to finish.
              return 1;
            }
          } else if (thread->in_stack_red_zone(addr)) {
            // Fatal red zone violation.  Disable the guard pages and fall through
            // to handle_unexpected_exception way down below.
--- 313,347 ----
  
        // Check if fault address is within thread stack.
        if (thread->on_local_stack(addr)) {
          // stack overflow
          if (thread->in_stack_yellow_reserved_zone(addr)) {
            if (thread->thread_state() == _thread_in_Java) {
+             if (thread->in_stack_reserved_zone(addr)) {
+               frame fr;
+               if (os::Linux::get_frame_at_stack_banging_point(thread, uc, &fr)) {
+                 assert(fr.is_java_frame(), "Must be a Javac frame");
+                 frame activation =
+                   SharedRuntime::look_for_reserved_stack_annotated_method(thread, fr);
+                 if (activation.sp() != NULL) {
+                   thread->disable_stack_reserved_zone();
+                   if (activation.is_interpreted_frame()) {
+                     thread->set_reserved_stack_activation((address)activation.fp());
+                   } else {
+                     thread->set_reserved_stack_activation((address)activation.unextended_sp());
+                   }
+                   return 1;
+                 }
+               }
+             }
              // Throw a stack overflow exception.
              // Guard pages will be reenabled while unwinding the stack.
+             thread->disable_stack_yellow_reserved_zone();
              stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
            } else {
              // Thread was in the vm or native code. Return and try to finish.
+             thread->disable_stack_yellow_reserved_zone();
              return 1;
            }
          } else if (thread->in_stack_red_zone(addr)) {
            // Fatal red zone violation.  Disable the guard pages and fall through
            // to handle_unexpected_exception way down below.