1 /*
   2  * Copyright (c) 2013, 2016, 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 import java.lang.management.ManagementFactory;
  25 import java.lang.management.ThreadInfo;
  26 import java.security.CodeSource;
  27 import java.security.Permission;
  28 import java.security.PermissionCollection;
  29 import java.security.Permissions;
  30 import java.security.Policy;
  31 import java.security.ProtectionDomain;
  32 import java.util.Enumeration;
  33 import java.util.concurrent.Semaphore;
  34 import java.util.concurrent.atomic.AtomicBoolean;
  35 import java.util.concurrent.atomic.AtomicInteger;
  36 import java.util.logging.LogManager;
  37 import java.util.logging.Logger;
  38 import jdk.internal.misc.JavaAWTAccess;
  39 import jdk.internal.misc.SharedSecrets;
  40 
  41 /**
  42  * @test
  43  * @bug 8065991
  44  * @summary check that when LogManager is initialized, a deadlock similar
  45  *          to that described in 8065709 will not occur.
  46  * @modules java.base/jdk.internal.misc
  47  *          java.logging
  48  *          java.management
  49  * @run main/othervm LogManagerAppContextDeadlock UNSECURE
  50  * @run main/othervm LogManagerAppContextDeadlock SECURE
  51  *
  52  * @author danielfuchs
  53  */
  54 public class LogManagerAppContextDeadlock {
  55 
  56     public static final Semaphore sem = new Semaphore(0);
  57     public static final Semaphore sem2 = new Semaphore(0);
  58     public static final Semaphore sem3 = new Semaphore(-2);
  59     public static volatile boolean goOn = true;
  60     public static volatile Exception thrown;
  61 
  62     // Emulate EventQueue
  63     static class FakeEventQueue {
  64         static final Logger logger = Logger.getLogger("foo");
  65     }
  66 
  67     // Emulate AppContext
  68     static class FakeAppContext {
  69 
  70         static final AtomicInteger numAppContexts = new AtomicInteger(0);
  71         static final class FakeAppContextLock {}
  72         static final FakeAppContextLock lock = new FakeAppContextLock();
  73         static volatile FakeAppContext appContext;
  74 
  75         final FakeEventQueue queue;
  76         FakeAppContext() {
  77             appContext = this;
  78             numAppContexts.incrementAndGet();
  79             // release sem2 to let Thread t2 call Logger.getLogger().
  80             sem2.release();
  81             try {
  82                 // Wait until we JavaAWTAccess is called by LogManager.
  83                 // Thread 2 will call Logger.getLogger() which will
  84                 // trigger a call to JavaAWTAccess - which will release
  85                 // sem, thus ensuring that Thread #2 is where we want it.
  86                 sem.acquire();
  87                 System.out.println("Sem acquired: Thread #2 has called JavaAWTAccess");
  88             } catch(InterruptedException x) {
  89                 Thread.interrupted();
  90             }
  91             queue = new FakeEventQueue();
  92         }
  93 
  94         static FakeAppContext getAppContext() {
  95             synchronized (lock) {
  96                 if (numAppContexts.get() == 0) {
  97                     return new FakeAppContext();
  98                 }
  99                 return appContext;
 100             }
 101         }
 102 
 103         static {
 104             SharedSecrets.setJavaAWTAccess(new JavaAWTAccess() {
 105                 @Override
 106                 public Object getAppletContext() {
 107                     if (numAppContexts.get() == 0) return null;
 108                     // We are in JavaAWTAccess, we can release sem and let
 109                     // FakeAppContext constructor proceeed.
 110                     System.out.println("Releasing Sem");
 111                     sem.release();
 112                     return getAppContext();
 113                 }
 114 
 115             });
 116         }
 117 
 118     }
 119 
 120 
 121     // Test with or without a security manager
 122     public static enum TestCase {
 123         UNSECURE, SECURE;
 124         public void run() throws Exception {
 125             System.out.println("Running test case: " + name());
 126             Configure.setUp(this);
 127             test(this);
 128         }
 129     }
 130 
 131     public static void test(TestCase test) throws Exception {
 132         Thread t1 = new Thread() {
 133             @Override
 134             public void run() {
 135                 sem3.release();
 136                 System.out.println("FakeAppContext.getAppContext()");
 137                 FakeAppContext.getAppContext();
 138                 System.out.println("Done: FakeAppContext.getAppContext()");
 139             }
 140         };
 141         t1.setDaemon(true);
 142         t1.start();
 143         Thread t2 = new Thread() {
 144             public Object logger;
 145             public void run() {
 146                 sem3.release();
 147                 try {
 148                     // Wait until Thread1 is in FakeAppContext constructor
 149                     sem2.acquire();
 150                     System.out.println("Sem2 acquired: Thread #1 will be waiting to acquire Sem");
 151                 } catch (InterruptedException ie) {
 152                     Thread.interrupted();
 153                 }
 154                 System.out.println("Logger.getLogger(name).info(name)");
 155                 // stick the logger in an instance variable to prevent it
 156                 // from being garbage collected before the main thread
 157                 // calls LogManager.getLogger() below.
 158                 logger = Logger.getLogger(test.name());//.info(name);
 159                 System.out.println("Done: Logger.getLogger(name).info(name)");
 160             }
 161         };
 162         t2.setDaemon(true);
 163         t2.start();
 164         System.out.println("Should exit now...");
 165         Thread detector = new DeadlockDetector();
 166         detector.start();
 167 
 168         // Wait for the 3 threads to start
 169         sem3.acquire();
 170 
 171         // Now wait for t1 & t2 to finish, or for a deadlock to be detected.
 172         while (goOn && (t1.isAlive() || t2.isAlive())) {
 173             if (t2.isAlive()) t2.join(1000);
 174             if (test == TestCase.UNSECURE && System.getSecurityManager() == null) {
 175                 // if there's no security manager, AppContext.getAppContext() is
 176                 // not called -  so Thread t2 will not end up calling
 177                 // sem.release(). In that case we must release the semaphore here
 178                 // so that t1 can proceed.
 179                 if (LogManager.getLogManager().getLogger(TestCase.UNSECURE.name()) != null) {
 180                     // means Thread t2 has created the logger
 181                     sem.release();
 182                 }
 183             }
 184             if (t1.isAlive()) t1.join(1000);
 185         }
 186         if (thrown != null) {
 187             throw thrown;
 188         }
 189     }
 190 
 191     // Thrown by the deadlock detector
 192     static final class DeadlockException extends RuntimeException {
 193         public DeadlockException(String message) {
 194             super(message);
 195         }
 196         @Override
 197         public void printStackTrace() {
 198         }
 199     }
 200 
 201     public static void main(String[] args) throws Exception {
 202 
 203         if (args.length == 0) {
 204             args = new String[] { "SECURE" };
 205         }
 206 
 207         // If we don't initialize LogManager here, there will be
 208         // a deadlock.
 209         // See <https://bugs.openjdk.java.net/browse/JDK-8065709?focusedCommentId=13582038&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-13582038>
 210         // for more details.
 211         Logger.getLogger("main").info("starting...");
 212         try {
 213             TestCase.valueOf(args[0]).run();
 214             System.out.println("Test "+args[0]+" Passed");
 215         } catch(Throwable t) {
 216             System.err.println("Test " + args[0] +" failed: " + t);
 217             t.printStackTrace();
 218         }
 219     }
 220 
 221     // Called by the deadlock detector when a deadlock is found.
 222     static void fail(Exception x) {
 223         x.printStackTrace();
 224         if (thrown == null) {
 225             thrown = x;
 226         }
 227         goOn = false;
 228     }
 229 
 230     // A thread that detect deadlocks.
 231     static final class DeadlockDetector extends Thread {
 232 
 233         public DeadlockDetector() {
 234             this.setDaemon(true);
 235         }
 236 
 237         @Override
 238         public void run() {
 239             sem3.release();
 240             Configure.doPrivileged(this::loop);
 241         }
 242         public void loop() {
 243             while(goOn) {
 244                 try {
 245                     long[] ids = ManagementFactory.getThreadMXBean().findDeadlockedThreads();
 246                     ids = ids == null ? new long[0] : ids;
 247                     if (ids.length == 1) {
 248                         throw new RuntimeException("Found 1 deadlocked thread: "+ids[0]);
 249                     } else if (ids.length > 0) {
 250                         ThreadInfo[] infos = ManagementFactory.getThreadMXBean().getThreadInfo(ids, Integer.MAX_VALUE);
 251                         System.err.println("Found "+ids.length+" deadlocked threads: ");
 252                         for (ThreadInfo inf : infos) {
 253                             System.err.println(inf);
 254                         }
 255                         throw new DeadlockException("Found "+ids.length+" deadlocked threads");
 256                     }
 257                     Thread.sleep(100);
 258                 } catch(InterruptedException | RuntimeException x) {
 259                     fail(x);
 260                 }
 261             }
 262         }
 263 
 264     }
 265 
 266     // A helper class to configure the security manager for the test,
 267     // and bypass it when needed.
 268     static class Configure {
 269         static Policy policy = null;
 270         static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
 271             @Override
 272             protected AtomicBoolean initialValue() {
 273                 return  new AtomicBoolean(false);
 274             }
 275         };
 276         static void setUp(TestCase test) {
 277             switch (test) {
 278                 case SECURE:
 279                     if (policy == null && System.getSecurityManager() != null) {
 280                         throw new IllegalStateException("SecurityManager already set");
 281                     } else if (policy == null) {
 282                         policy = new SimplePolicy(TestCase.SECURE, allowAll);
 283                         Policy.setPolicy(policy);
 284                         System.setSecurityManager(new SecurityManager());
 285                     }
 286                     if (System.getSecurityManager() == null) {
 287                         throw new IllegalStateException("No SecurityManager.");
 288                     }
 289                     if (policy == null) {
 290                         throw new IllegalStateException("policy not configured");
 291                     }
 292                     break;
 293                 case UNSECURE:
 294                     if (System.getSecurityManager() != null) {
 295                         throw new IllegalStateException("SecurityManager already set");
 296                     }
 297                     break;
 298                 default:
 299                     new InternalError("No such testcase: " + test);
 300             }
 301         }
 302         static void doPrivileged(Runnable run) {
 303             allowAll.get().set(true);
 304             try {
 305                 run.run();
 306             } finally {
 307                 allowAll.get().set(false);
 308             }
 309         }
 310     }
 311 
 312     // A Helper class to build a set of permissions.
 313     static final class PermissionsBuilder {
 314         final Permissions perms;
 315         public PermissionsBuilder() {
 316             this(new Permissions());
 317         }
 318         public PermissionsBuilder(Permissions perms) {
 319             this.perms = perms;
 320         }
 321         public PermissionsBuilder add(Permission p) {
 322             perms.add(p);
 323             return this;
 324         }
 325         public PermissionsBuilder addAll(PermissionCollection col) {
 326             if (col != null) {
 327                 for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
 328                     perms.add(e.nextElement());
 329                 }
 330             }
 331             return this;
 332         }
 333         public Permissions toPermissions() {
 334             final PermissionsBuilder builder = new PermissionsBuilder();
 335             builder.addAll(perms);
 336             return builder.perms;
 337         }
 338     }
 339 
 340     // Policy for the test...
 341     public static class SimplePolicy extends Policy {
 342 
 343         final Permissions permissions;
 344         final Permissions allPermissions;
 345         final ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
 346         public SimplePolicy(TestCase test, ThreadLocal<AtomicBoolean> allowAll) {
 347             this.allowAll = allowAll;
 348             // we don't actually need any permission to create our
 349             // FileHandlers because we're passing invalid parameters
 350             // which will make the creation fail...
 351             permissions = new Permissions();
 352             permissions.add(new RuntimePermission("accessClassInPackage.jdk.internal.misc"));
 353 
 354             // these are used for configuring the test itself...
 355             allPermissions = new Permissions();
 356             allPermissions.add(new java.security.AllPermission());
 357 
 358         }
 359 
 360         @Override
 361         public boolean implies(ProtectionDomain domain, Permission permission) {
 362             if (allowAll.get().get()) return allPermissions.implies(permission);
 363             return permissions.implies(permission);
 364         }
 365 
 366         @Override
 367         public PermissionCollection getPermissions(CodeSource codesource) {
 368             return new PermissionsBuilder().addAll(allowAll.get().get()
 369                     ? allPermissions : permissions).toPermissions();
 370         }
 371 
 372         @Override
 373         public PermissionCollection getPermissions(ProtectionDomain domain) {
 374             return new PermissionsBuilder().addAll(allowAll.get().get()
 375                     ? allPermissions : permissions).toPermissions();
 376         }
 377     }
 378 
 379 }
--- EOF ---