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 void run() {
 145                 sem3.release();
 146                 try {
 147                     // Wait until Thread1 is in FakeAppContext constructor
 148                     sem2.acquire();
 149                     System.out.println("Sem2 acquired: Thread #1 will be waiting to acquire Sem");
 150                 } catch (InterruptedException ie) {
 151                     Thread.interrupted();
 152                 }
 153                 System.out.println("Logger.getLogger(name).info(name)");
 154                 Logger.getLogger(test.name());//.info(name);



 155                 System.out.println("Done: Logger.getLogger(name).info(name)");
 156             }
 157         };
 158         t2.setDaemon(true);
 159         t2.start();
 160         System.out.println("Should exit now...");
 161         Thread detector = new DeadlockDetector();
 162         detector.start();
 163 
 164         // Wait for the 3 threads to start
 165         sem3.acquire();
 166 
 167         // Now wait for t1 & t2 to finish, or for a deadlock to be detected.
 168         while (goOn && (t1.isAlive() || t2.isAlive())) {
 169             if (t2.isAlive()) t2.join(1000);
 170             if (test == TestCase.UNSECURE && System.getSecurityManager() == null) {
 171                 // if there's no security manager, AppContext.getAppContext() is
 172                 // not called -  so Thread t2 will not end up calling
 173                 // sem.release(). In that case we must release the semaphore here
 174                 // so that t1 can proceed.
 175                 if (LogManager.getLogManager().getLogger(TestCase.UNSECURE.name()) != null) {
 176                     // means Thread t2 has created the logger
 177                     sem.release();
 178                 }
 179             }
 180             if (t1.isAlive()) t1.join(1000);
 181         }
 182         if (thrown != null) {
 183             throw thrown;
 184         }
 185     }
 186 
 187     // Thrown by the deadlock detector
 188     static final class DeadlockException extends RuntimeException {
 189         public DeadlockException(String message) {
 190             super(message);
 191         }
 192         @Override
 193         public void printStackTrace() {
 194         }
 195     }
 196 
 197     public static void main(String[] args) throws Exception {
 198 
 199         if (args.length == 0) {
 200             args = new String[] { "SECURE" };
 201         }
 202 
 203         // If we don't initialize LogManager here, there will be
 204         // a deadlock.
 205         // See <https://bugs.openjdk.java.net/browse/JDK-8065709?focusedCommentId=13582038&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-13582038>
 206         // for more details.
 207         Logger.getLogger("main").info("starting...");
 208         try {
 209             TestCase.valueOf(args[0]).run();
 210             System.out.println("Test "+args[0]+" Passed");
 211         } catch(Throwable t) {
 212             System.err.println("Test " + args[0] +" failed: " + t);
 213             t.printStackTrace();
 214         }
 215     }
 216 
 217     // Called by the deadlock detector when a deadlock is found.
 218     static void fail(Exception x) {
 219         x.printStackTrace();
 220         if (thrown == null) {
 221             thrown = x;
 222         }
 223         goOn = false;
 224     }
 225 
 226     // A thread that detect deadlocks.
 227     static final class DeadlockDetector extends Thread {
 228 
 229         public DeadlockDetector() {
 230             this.setDaemon(true);
 231         }
 232 
 233         @Override
 234         public void run() {
 235             sem3.release();
 236             Configure.doPrivileged(this::loop);
 237         }
 238         public void loop() {
 239             while(goOn) {
 240                 try {
 241                     long[] ids = ManagementFactory.getThreadMXBean().findDeadlockedThreads();
 242                     ids = ids == null ? new long[0] : ids;
 243                     if (ids.length == 1) {
 244                         throw new RuntimeException("Found 1 deadlocked thread: "+ids[0]);
 245                     } else if (ids.length > 0) {
 246                         ThreadInfo[] infos = ManagementFactory.getThreadMXBean().getThreadInfo(ids, Integer.MAX_VALUE);
 247                         System.err.println("Found "+ids.length+" deadlocked threads: ");
 248                         for (ThreadInfo inf : infos) {
 249                             System.err.println(inf);
 250                         }
 251                         throw new DeadlockException("Found "+ids.length+" deadlocked threads");
 252                     }
 253                     Thread.sleep(100);
 254                 } catch(InterruptedException | RuntimeException x) {
 255                     fail(x);
 256                 }
 257             }
 258         }
 259 
 260     }
 261 
 262     // A helper class to configure the security manager for the test,
 263     // and bypass it when needed.
 264     static class Configure {
 265         static Policy policy = null;
 266         static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
 267             @Override
 268             protected AtomicBoolean initialValue() {
 269                 return  new AtomicBoolean(false);
 270             }
 271         };
 272         static void setUp(TestCase test) {
 273             switch (test) {
 274                 case SECURE:
 275                     if (policy == null && System.getSecurityManager() != null) {
 276                         throw new IllegalStateException("SecurityManager already set");
 277                     } else if (policy == null) {
 278                         policy = new SimplePolicy(TestCase.SECURE, allowAll);
 279                         Policy.setPolicy(policy);
 280                         System.setSecurityManager(new SecurityManager());
 281                     }
 282                     if (System.getSecurityManager() == null) {
 283                         throw new IllegalStateException("No SecurityManager.");
 284                     }
 285                     if (policy == null) {
 286                         throw new IllegalStateException("policy not configured");
 287                     }
 288                     break;
 289                 case UNSECURE:
 290                     if (System.getSecurityManager() != null) {
 291                         throw new IllegalStateException("SecurityManager already set");
 292                     }
 293                     break;
 294                 default:
 295                     new InternalError("No such testcase: " + test);
 296             }
 297         }
 298         static void doPrivileged(Runnable run) {
 299             allowAll.get().set(true);
 300             try {
 301                 run.run();
 302             } finally {
 303                 allowAll.get().set(false);
 304             }
 305         }
 306     }
 307 
 308     // A Helper class to build a set of permissions.
 309     static final class PermissionsBuilder {
 310         final Permissions perms;
 311         public PermissionsBuilder() {
 312             this(new Permissions());
 313         }
 314         public PermissionsBuilder(Permissions perms) {
 315             this.perms = perms;
 316         }
 317         public PermissionsBuilder add(Permission p) {
 318             perms.add(p);
 319             return this;
 320         }
 321         public PermissionsBuilder addAll(PermissionCollection col) {
 322             if (col != null) {
 323                 for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
 324                     perms.add(e.nextElement());
 325                 }
 326             }
 327             return this;
 328         }
 329         public Permissions toPermissions() {
 330             final PermissionsBuilder builder = new PermissionsBuilder();
 331             builder.addAll(perms);
 332             return builder.perms;
 333         }
 334     }
 335 
 336     // Policy for the test...
 337     public static class SimplePolicy extends Policy {
 338 
 339         final Permissions permissions;
 340         final Permissions allPermissions;
 341         final ThreadLocal<AtomicBoolean> allowAll; // actually: this should be in a thread locale
 342         public SimplePolicy(TestCase test, ThreadLocal<AtomicBoolean> allowAll) {
 343             this.allowAll = allowAll;
 344             // we don't actually need any permission to create our
 345             // FileHandlers because we're passing invalid parameters
 346             // which will make the creation fail...
 347             permissions = new Permissions();
 348             permissions.add(new RuntimePermission("accessClassInPackage.jdk.internal.misc"));
 349 
 350             // these are used for configuring the test itself...
 351             allPermissions = new Permissions();
 352             allPermissions.add(new java.security.AllPermission());
 353 
 354         }
 355 
 356         @Override
 357         public boolean implies(ProtectionDomain domain, Permission permission) {
 358             if (allowAll.get().get()) return allPermissions.implies(permission);
 359             return permissions.implies(permission);
 360         }
 361 
 362         @Override
 363         public PermissionCollection getPermissions(CodeSource codesource) {
 364             return new PermissionsBuilder().addAll(allowAll.get().get()
 365                     ? allPermissions : permissions).toPermissions();
 366         }
 367 
 368         @Override
 369         public PermissionCollection getPermissions(ProtectionDomain domain) {
 370             return new PermissionsBuilder().addAll(allowAll.get().get()
 371                     ? allPermissions : permissions).toPermissions();
 372         }
 373     }
 374 
 375 }
--- EOF ---