1 /*
   2  * Copyright (c) 1999, 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 java.lang;
  27 
  28 
  29 /**
  30  * Package-private utility class containing data structures and logic
  31  * governing the virtual-machine shutdown sequence.
  32  *
  33  * @author   Mark Reinhold
  34  * @since    1.3
  35  */
  36 
  37 class Shutdown {
  38 
  39     /* Shutdown state */
  40     private static final int RUNNING = 0;
  41     private static final int HOOKS = 1;
  42     private static final int FINALIZERS = 2;
  43     private static int state = RUNNING;
  44 
  45     /* Should we run all finalizers upon exit? */
  46     private static boolean runFinalizersOnExit = false;
  47 
  48     // The system shutdown hooks are registered with a predefined slot.
  49     // The list of shutdown hooks is as follows:
  50     // (0) Console restore hook
  51     // (1) Application hooks
  52     // (2) DeleteOnExit hook
  53     private static final int MAX_SYSTEM_HOOKS = 10;
  54     private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
  55 
  56     // the index of the currently running shutdown hook to the hooks array
  57     private static int currentRunningHook = 0;
  58 
  59     /* The preceding static fields are protected by this lock */
  60     private static class Lock { };
  61     private static Object lock = new Lock();
  62 
  63     /* Lock object for the native halt method */
  64     private static Object haltLock = new Lock();
  65 
  66     /* Invoked by Runtime.runFinalizersOnExit */
  67     static void setRunFinalizersOnExit(boolean run) {
  68         synchronized (lock) {
  69             runFinalizersOnExit = run;
  70         }
  71     }
  72 
  73 
  74     /**
  75      * Add a new shutdown hook.  Checks the shutdown state and the hook itself,
  76      * but does not do any security checks.
  77      *
  78      * The registerShutdownInProgress parameter should be false except
  79      * registering the DeleteOnExitHook since the first file may
  80      * be added to the delete on exit list by the application shutdown
  81      * hooks.
  82      *
  83      * @params slot  the slot in the shutdown hook array, whose element
  84      *               will be invoked in order during shutdown
  85      * @params registerShutdownInProgress true to allow the hook
  86      *               to be registered even if the shutdown is in progress.
  87      * @params hook  the hook to be registered
  88      *
  89      * @throw IllegalStateException
  90      *        if registerShutdownInProgress is false and shutdown is in progress; or
  91      *        if registerShutdownInProgress is true and the shutdown process
  92      *           already passes the given slot
  93      */
  94     static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
  95         synchronized (lock) {
  96             if (hooks[slot] != null)
  97                 throw new InternalError("Shutdown hook at slot " + slot + " already registered");
  98 
  99             if (!registerShutdownInProgress) {
 100                 if (state > RUNNING)
 101                     throw new IllegalStateException("Shutdown in progress");
 102             } else {
 103                 if (state > HOOKS || (state == HOOKS && slot <= currentRunningHook))
 104                     throw new IllegalStateException("Shutdown in progress");
 105             }
 106 
 107             hooks[slot] = hook;
 108         }
 109     }
 110 
 111     /* Run all registered shutdown hooks
 112      */
 113     private static void runHooks() {
 114         for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
 115             try {
 116                 Runnable hook;
 117                 synchronized (lock) {
 118                     // acquire the lock to make sure the hook registered during
 119                     // shutdown is visible here.
 120                     currentRunningHook = i;
 121                     hook = hooks[i];
 122                 }
 123                 if (hook != null) hook.run();
 124             } catch(Throwable t) {
 125                 if (t instanceof ThreadDeath) {
 126                     ThreadDeath td = (ThreadDeath)t;
 127                     throw td;
 128                 }
 129             }
 130         }
 131     }
 132 
 133     /* Notify the VM that it's time to halt. */
 134     static native void beforeHalt();
 135 
 136     /* The halt method is synchronized on the halt lock
 137      * to avoid corruption of the delete-on-shutdown file list.
 138      * It invokes the true native halt method.
 139      */
 140     static void halt(int status) {
 141         synchronized (haltLock) {
 142             halt0(status);
 143         }
 144     }
 145 
 146     static native void halt0(int status);
 147 
 148     /* Wormhole for invoking java.lang.ref.Finalizer.runAllFinalizers */
 149     private static native void runAllFinalizers();
 150 
 151 
 152     /* The actual shutdown sequence is defined here.
 153      *
 154      * If it weren't for runFinalizersOnExit, this would be simple -- we'd just
 155      * run the hooks and then halt.  Instead we need to keep track of whether
 156      * we're running hooks or finalizers.  In the latter case a finalizer could
 157      * invoke exit(1) to cause immediate termination, while in the former case
 158      * any further invocations of exit(n), for any n, simply stall.  Note that
 159      * if on-exit finalizers are enabled they're run iff the shutdown is
 160      * initiated by an exit(0); they're never run on exit(n) for n != 0 or in
 161      * response to SIGINT, SIGTERM, etc.
 162      */
 163     private static void sequence() {
 164         synchronized (lock) {
 165             /* Guard against the possibility of a daemon thread invoking exit
 166              * after DestroyJavaVM initiates the shutdown sequence
 167              */
 168             if (state != HOOKS) return;
 169         }
 170         runHooks();
 171         boolean rfoe;
 172         synchronized (lock) {
 173             state = FINALIZERS;
 174             rfoe = runFinalizersOnExit;
 175         }
 176         if (rfoe) runAllFinalizers();
 177     }
 178 
 179 
 180     /* Invoked by Runtime.exit, which does all the security checks.
 181      * Also invoked by handlers for system-provided termination events,
 182      * which should pass a nonzero status code.
 183      */
 184     static void exit(int status) {
 185         boolean runMoreFinalizers = false;
 186         synchronized (lock) {
 187             if (status != 0) runFinalizersOnExit = false;
 188             switch (state) {
 189             case RUNNING:       /* Initiate shutdown */
 190                 state = HOOKS;
 191                 break;
 192             case HOOKS:         /* Stall and halt */
 193                 break;
 194             case FINALIZERS:
 195                 if (status != 0) {
 196                     /* Halt immediately on nonzero status */
 197                     halt(status);
 198                 } else {
 199                     /* Compatibility with old behavior:
 200                      * Run more finalizers and then halt
 201                      */
 202                     runMoreFinalizers = runFinalizersOnExit;
 203                 }
 204                 break;
 205             }
 206         }
 207         if (runMoreFinalizers) {
 208             runAllFinalizers();
 209             halt(status);
 210         }
 211         synchronized (Shutdown.class) {
 212             /* Synchronize on the class object, causing any other thread
 213              * that attempts to initiate shutdown to stall indefinitely
 214              */
 215             beforeHalt();
 216             sequence();
 217             halt(status);
 218         }
 219     }
 220 
 221 
 222     /* Invoked by the JNI DestroyJavaVM procedure when the last non-daemon
 223      * thread has finished.  Unlike the exit method, this method does not
 224      * actually halt the VM.
 225      */
 226     static void shutdown() {
 227         synchronized (lock) {
 228             switch (state) {
 229             case RUNNING:       /* Initiate shutdown */
 230                 state = HOOKS;
 231                 break;
 232             case HOOKS:         /* Stall and then return */
 233             case FINALIZERS:
 234                 break;
 235             }
 236         }
 237         synchronized (Shutdown.class) {
 238             sequence();
 239         }
 240     }
 241 
 242 }