Mercurial > hg > release > icedtea6-1.13
changeset 2955:7b540332f735
Fix regressions caused by security patches.
S8004341: Two JCK tests fails with 7u11 b06
S8005615: Java Logger fails to load tomcat logger implementation (JULI)
2013-02-08 Andrew John Hughes <gnu.andrew@redhat.com>
* Makefile.am:
(ICEDTEA_PATCHES): Add additional patches to
fix regressions introduced by security fixes
6664509 & 7201064.
* patches/openjdk/8004341-jck_dialog_failure.patch:
Fix issue with Dialog serialization.
* patches/openjdk/8005615-failure_to_load_logger_implementation.patch:
Fix issue with use of custom LogManagers.
author | Andrew John Hughes <gnu.andrew@redhat.com> |
---|---|
date | Wed, 13 Feb 2013 18:24:03 +0000 |
parents | 55c6b6c6e0af |
children | c3ecc5528bc0 |
files | ChangeLog Makefile.am patches/openjdk/8004341-jck_dialog_failure.patch patches/openjdk/8005615-failure_to_load_logger_implementation.patch |
diffstat | 4 files changed, 582 insertions(+), 1 deletions(-) [+] |
line wrap: on
line diff
--- a/ChangeLog Mon Feb 04 00:59:08 2013 -0500 +++ b/ChangeLog Wed Feb 13 18:24:03 2013 +0000 @@ -1,3 +1,14 @@ +2013-02-08 Andrew John Hughes <gnu.andrew@redhat.com> + + * Makefile.am: + (ICEDTEA_PATCHES): Add additional patches to + fix regressions introduced by security fixes + 6664509 & 7201064. + * patches/openjdk/8004341-jck_dialog_failure.patch: + Fix issue with Dialog serialization. + * patches/openjdk/8005615-failure_to_load_logger_implementation.patch: + Fix issue with use of custom LogManagers. + 2013-02-04 Andrew John Hughes <gnu.andrew@redhat.com> Omair Majid <omajid@redhat.com>
--- a/Makefile.am Mon Feb 04 00:59:08 2013 -0500 +++ b/Makefile.am Wed Feb 13 18:24:03 2013 +0000 @@ -500,7 +500,9 @@ patches/openjdk/6980681-corba_deadlock.patch \ patches/openjdk/7162902-corba_fixes.patch \ patches/traceable.patch \ - patches/openjdk/7010849-modernise_sa.patch + patches/openjdk/7010849-modernise_sa.patch \ + patches/openjdk/8005615-failure_to_load_logger_implementation.patch \ + patches/openjdk/8004341-jck_dialog_failure.patch if WITH_RHINO ICEDTEA_PATCHES += \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/8004341-jck_dialog_failure.patch Wed Feb 13 18:24:03 2013 +0000 @@ -0,0 +1,26 @@ +# HG changeset patch +# User denis +# Date 1355221156 -14400 +# Node ID 090b35175a91906d75050f12a5f3e54c7da199e9 +# Parent 52029bcc00e103876c5149d7f95d9246e73d3435 +8004341: Two JCK tests fails with 7u11 b06 +Reviewed-by: serb, skoivu + +diff --git a/src/share/classes/java/awt/Dialog.java b/src/share/classes/java/awt/Dialog.java +--- openjdk/jdk/src/share/classes/java/awt/Dialog.java ++++ openjdk/jdk/src/share/classes/java/awt/Dialog.java +@@ -1631,12 +1631,13 @@ + if (localModalityType == null) { + this.modal = fields.get("modal", false); + setModal(modal); ++ } else { ++ this.modalityType = localModalityType; + } + + this.resizable = fields.get("resizable", true); + this.undecorated = fields.get("undecorated", false); + this.title = (String)fields.get("title", ""); +- this.modalityType = localModalityType; + + blockedWindows = new IdentityArrayList(); +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/openjdk/8005615-failure_to_load_logger_implementation.patch Wed Feb 13 18:24:03 2013 +0000 @@ -0,0 +1,542 @@ +# HG changeset patch +# User coffeys +# Date 1360107230 0 +# Node ID cff0241d217f7b463d58ddcd0add8d41de9eb280 +# Parent dabed5898de907431b524952aade46f0b6b960aa +8005615: Java Logger fails to load tomcat logger implementation (JULI) +Reviewed-by: mchung + +diff --git a/src/share/classes/java/util/logging/LogManager.java b/src/share/classes/java/util/logging/LogManager.java +--- openjdk/jdk/src/share/classes/java/util/logging/LogManager.java ++++ openjdk/jdk/src/share/classes/java/util/logging/LogManager.java +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it +@@ -159,7 +159,7 @@ + + // LoggerContext for system loggers and user loggers + private final LoggerContext systemContext = new SystemLoggerContext(); +- private final LoggerContext userContext = new UserLoggerContext(); ++ private final LoggerContext userContext = new LoggerContext(); + private Logger rootLogger; + + // Have we done the primordial reading of the configuration file? +@@ -197,13 +197,13 @@ + + // Create and retain Logger for the root of the namespace. + manager.rootLogger = manager.new RootLogger(); +- manager.systemContext.addLogger(manager.rootLogger); +- manager.userContext.addLogger(manager.rootLogger); ++ manager.addLogger(manager.rootLogger); ++ manager.systemContext.addLocalLogger(manager.rootLogger); + + // Adding the global Logger. Doing so in the Logger.<clinit> + // would deadlock with the LogManager.<clinit>. + Logger.global.setLogManager(manager); +- manager.systemContext.addLogger(Logger.global); ++ manager.addLogger(Logger.global); + + // We don't call readConfiguration() here, as we may be running + // very early in the JVM startup sequence. Instead readConfiguration +@@ -329,7 +329,7 @@ + + // Returns the LoggerContext for the user code (i.e. application or AppContext). + // Loggers are isolated from each AppContext. +- LoggerContext getUserContext() { ++ private LoggerContext getUserContext() { + LoggerContext context = null; + + SecurityManager sm = System.getSecurityManager(); +@@ -350,8 +350,8 @@ + if (javaAwtAccess.isMainAppContext()) { + context = userContext; + } else { +- context = new UserLoggerContext(); +- context.addLogger(manager.rootLogger); ++ context = new LoggerContext(); ++ context.addLocalLogger(manager.rootLogger); + } + javaAwtAccess.put(ecx, LoggerContext.class, context); + } +@@ -362,10 +362,6 @@ + return context; + } + +- LoggerContext getSystemContext() { +- return systemContext; +- } +- + private List<LoggerContext> contexts() { + List<LoggerContext> cxs = new ArrayList<LoggerContext>(); + cxs.add(systemContext); +@@ -373,6 +369,58 @@ + return cxs; + } + ++ // Find or create a specified logger instance. If a logger has ++ // already been created with the given name it is returned. ++ // Otherwise a new logger instance is created and registered ++ // in the LogManager global namespace. ++ // This method will always return a non-null Logger object. ++ // Synchronization is not required here. All synchronization for ++ // adding a new Logger object is handled by addLogger(). ++ // ++ // This method must delegate to the LogManager implementation to ++ // add a new Logger or return the one that has been added previously ++ // as a LogManager subclass may override the addLogger, getLogger, ++ // readConfiguration, and other methods. ++ Logger demandLogger(String name, String resourceBundleName) { ++ Logger result = getLogger(name); ++ if (result == null) { ++ // only allocate the new logger once ++ Logger newLogger = new Logger(name, resourceBundleName); ++ do { ++ if (addLogger(newLogger)) { ++ // We successfully added the new Logger that we ++ // created above so return it without refetching. ++ return newLogger; ++ } ++ ++ // We didn't add the new Logger that we created above ++ // because another thread added a Logger with the same ++ // name after our null check above and before our call ++ // to addLogger(). We have to refetch the Logger because ++ // addLogger() returns a boolean instead of the Logger ++ // reference itself. However, if the thread that created ++ // the other Logger is not holding a strong reference to ++ // the other Logger, then it is possible for the other ++ // Logger to be GC'ed after we saw it in addLogger() and ++ // before we can refetch it. If it has been GC'ed then ++ // we'll just loop around and try again. ++ result = getLogger(name); ++ } while (result == null); ++ } ++ return result; ++ } ++ ++ Logger demandSystemLogger(String name, String resourceBundleName) { ++ return systemContext.demandLogger(name, resourceBundleName); ++ } ++ ++ // LoggerContext maintains the logger namespace per context. ++ // The default LogManager implementation has one system context and user ++ // context. The system context is used to maintain the namespace for ++ // all system loggers and is queried by the system code. If a system logger ++ // doesn't exist in the user context, it'll also be added to the user context. ++ // The user context is queried by the user code and all other loggers are ++ // added in the user context. + static class LoggerContext { + // Table of named Loggers that maps names to Loggers. + +@@ -385,6 +433,12 @@ + this.root = new LogNode(null, this); + } + ++ Logger demandLogger(String name, String resourceBundleName) { ++ // a LogManager subclass may have its own implementation to add and ++ // get a Logger. So delegate to the LogManager to do the work. ++ return manager.demandLogger(name, resourceBundleName); ++ } ++ + synchronized Logger findLogger(String name) { + LoggerWeakRef ref = namedLoggers.get(name); + if (ref == null) { +@@ -399,7 +453,9 @@ + return logger; + } + +- synchronized boolean addLogger(Logger logger) { ++ // Add a logger to this context. This method will only set its level ++ // and process parent loggers. It doesn't set its handlers. ++ synchronized boolean addLocalLogger(Logger logger) { + final String name = logger.getName(); + if (name == null) { + throw new NullPointerException(); +@@ -432,9 +488,6 @@ + doSetLevel(logger, level); + } + +- // Do we have a per logger handler too? +- // Note: this will add a 200ms penalty +- manager.loadLoggerHandlers(logger, name, name + ".handlers"); + processParentHandlers(logger, name); + + // Find the new node and its parent. +@@ -471,49 +524,21 @@ + return namedLoggers.keys(); + } + +- Logger demandLogger(String name) { +- return demandLogger(name, null); +- } +- +- // Find or create a specified logger instance. If a logger has +- // already been created with the given name it is returned. +- // Otherwise a new logger instance is created and registered +- // in the LogManager global namespace. +- // This method will always return a non-null Logger object. +- // Synchronization is not required here. All synchronization for +- // adding a new Logger object is handled by addLogger(). +- Logger demandLogger(String name, String resourceBundleName) { +- Logger result = findLogger(name); +- if (result == null) { +- // only allocate the new logger once +- Logger newLogger = new Logger(name, resourceBundleName); +- do { +- if (addLogger(newLogger)) { +- // We successfully added the new Logger that we +- // created above so return it without refetching. +- return newLogger; +- } +- +- // We didn't add the new Logger that we created above +- // because another thread added a Logger with the same +- // name after our null check above and before our call +- // to addLogger(). We have to refetch the Logger because +- // addLogger() returns a boolean instead of the Logger +- // reference itself. However, if the thread that created +- // the other Logger is not holding a strong reference to +- // the other Logger, then it is possible for the other +- // Logger to be GC'ed after we saw it in addLogger() and +- // before we can refetch it. If it has been GC'ed then +- // we'll just loop around and try again. +- result = findLogger(name); +- } while (result == null); +- } +- return result; +- } +- + // If logger.getUseParentHandlers() returns 'true' and any of the logger's + // parents have levels or handlers defined, make sure they are instantiated. +- private void processParentHandlers(Logger logger, String name) { ++ private void processParentHandlers(final Logger logger, final String name) { ++ AccessController.doPrivileged(new PrivilegedAction<Void>() { ++ public Void run() { ++ if (logger != manager.rootLogger) { ++ boolean useParent = manager.getBooleanProperty(name + ".useParentHandlers", true); ++ if (!useParent) { ++ logger.setUseParentHandlers(false); ++ } ++ } ++ return null; ++ } ++ }); ++ + int ix = 1; + for (;;) { + int ix2 = name.indexOf(".", ix); +@@ -526,12 +551,12 @@ + || manager.getProperty(pname + ".handlers") != null) { + // This pname has a level/handlers definition. + // Make sure it exists. +- demandLogger(pname); ++ demandLogger(pname, null); + } + ix = ix2 + 1; + } + } +- ++ + // Gets a node in our tree of logger nodes. + // If necessary, create it. + LogNode getNode(String name) { +@@ -564,74 +589,55 @@ + } + + static class SystemLoggerContext extends LoggerContext { +- // Default resource bundle for all system loggers +- +- Logger demandLogger(String name) { +- // default to use the system logger's resource bundle +- return super.demandLogger(name, Logger.SYSTEM_LOGGER_RB_NAME); +- } +- } +- +- static class UserLoggerContext extends LoggerContext { +- +- /** +- * Returns a Logger of the given name if there is one registered +- * in this context. Otherwise, it will return the one registered +- * in the system context if there is one. The returned Logger +- * instance may be initialized with a different resourceBundleName. +- * If no such logger exists, a new Logger instance will be created +- * and registered in this context. +- */ ++ // Add a system logger in the system context's namespace as well as ++ // in the LogManager's namespace if not exist so that there is only ++ // one single logger of the given name. System loggers are visible ++ // to applications unless a logger of the same name has been added. + Logger demandLogger(String name, String resourceBundleName) { + Logger result = findLogger(name); + if (result == null) { +- // use the system logger if exists; or allocate a new logger. +- // The system logger is added to the app logger context so that +- // any child logger created in the app logger context can have +- // a system logger as its parent if already exist. +- Logger logger = manager.systemContext.findLogger(name); +- Logger newLogger = +- logger != null ? logger : new Logger(name, resourceBundleName); ++ // only allocate the new system logger once ++ Logger newLogger = new Logger(name, resourceBundleName); + do { +- if (addLogger(newLogger)) { ++ if (addLocalLogger(newLogger)) { + // We successfully added the new Logger that we + // created above so return it without refetching. +- return newLogger; ++ result = newLogger; ++ } else { ++ // We didn't add the new Logger that we created above ++ // because another thread added a Logger with the same ++ // name after our null check above and before our call ++ // to addLogger(). We have to refetch the Logger because ++ // addLogger() returns a boolean instead of the Logger ++ // reference itself. However, if the thread that created ++ // the other Logger is not holding a strong reference to ++ // the other Logger, then it is possible for the other ++ // Logger to be GC'ed after we saw it in addLogger() and ++ // before we can refetch it. If it has been GC'ed then ++ // we'll just loop around and try again. ++ result = findLogger(name); + } +- +- // We didn't add the new Logger that we created above +- // because another thread added a Logger with the same +- // name after our null check above and before our call +- // to addLogger(). We have to refetch the Logger because +- // addLogger() returns a boolean instead of the Logger +- // reference itself. However, if the thread that created +- // the other Logger is not holding a strong reference to +- // the other Logger, then it is possible for the other +- // Logger to be GC'ed after we saw it in addLogger() and +- // before we can refetch it. If it has been GC'ed then +- // we'll just loop around and try again. +- result = findLogger(name); + } while (result == null); + } +- return result; ++ // Add the system logger to the LogManager's namespace if not exists ++ // The LogManager will set its handlers via the LogManager.addLogger method. ++ if (!manager.addLogger(result) && result.getHandlers().length == 0) { ++ // if logger already exists but handlers not set ++ final Logger l = manager.getLogger(name); ++ final Logger logger = result; ++ AccessController.doPrivileged(new PrivilegedAction<Void>() { ++ public Void run() { ++ for (Handler hdl : l.getHandlers()) { ++ logger.addHandler(hdl); ++ } ++ return null; ++ } ++ }); ++ } ++ return result; + } + } + +- // Package-level method. +- // Find or create a specified logger instance. If a logger has +- // already been created with the given name it is returned. +- // Otherwise a new logger instance is created and registered +- // in the LogManager global namespace. +- synchronized Logger demandLogger(String name) { +- Logger result = getLogger(name); +- if (result == null) { +- result = new Logger(name, null); +- addLogger(result); +- result = getLogger(name); +- } +- return result; +- } +- + // Add new per logger handlers. + // We need to raise privilege here. All our decisions will + // be made based on the logging configuration, which can +@@ -640,12 +646,6 @@ + final String handlersPropertyName) { + AccessController.doPrivileged(new PrivilegedAction<Object>() { + public Object run() { +- if (logger != rootLogger) { +- boolean useParent = getBooleanProperty(name + ".useParentHandlers", true); +- if (!useParent) { +- logger.setUseParentHandlers(false); +- } +- } + + String names[] = parseClassNames(handlersPropertyName); + for (int i = 0; i < names.length; i++) { +@@ -674,10 +674,10 @@ + } + } + return null; +- }}); ++ } ++ }); + } + +- + // loggerRefQueue holds LoggerWeakRef objects for Logger objects + // that have been GC'ed. + private final ReferenceQueue<Logger> loggerRefQueue +@@ -815,10 +815,15 @@ + if (name == null) { + throw new NullPointerException(); + } +- if (systemContext.findLogger(name) != null) { ++ LoggerContext cx = getUserContext(); ++ if (cx.addLocalLogger(logger)) { ++ // Do we have a per logger handler too? ++ // Note: this will add a 200ms penalty ++ loadLoggerHandlers(logger, name, name + ".handlers"); ++ return true; ++ } else { + return false; + } +- return getUserContext().addLogger(logger); + } + + // Private method to set a level on a logger. +@@ -839,8 +844,6 @@ + }}); + } + +- +- + // Private method to set a parent on a logger. + // If necessary, we raise privilege before doing the setParent call. + private static void doSetParent(final Logger logger, final Logger parent) { +@@ -875,15 +878,7 @@ + * @return matching logger or null if none is found + */ + public Logger getLogger(String name) { +- // return the first logger added +- // +- // once a system logger is added in the system context, no one can +- // adds a logger with the same name in the global context +- // (see LogManager.addLogger). So if there is a logger in the global +- // context with the same name as one in the system context, it must be +- // added before the system logger was created. +- Logger logger = getUserContext().findLogger(name); +- return logger != null ? logger : systemContext.findLogger(name); ++ return getUserContext().findLogger(name); + } + + /** +@@ -903,11 +898,7 @@ + * @return enumeration of logger name strings + */ + public Enumeration<String> getLoggerNames() { +- // only return unique names +- Set<String> names = +- new HashSet<String>(Collections.list(systemContext.getLoggerNames())); +- names.addAll(Collections.list(getUserContext().getLoggerNames())); +- return Collections.enumeration(names); ++ return getUserContext().getLoggerNames(); + } + + /** +@@ -1229,7 +1220,6 @@ + loadLoggerHandlers(rootLogger, null, "handlers"); + } + +- + private final Permission controlPermission = new LoggingPermission("control", null); + + void checkPermission() { +@@ -1288,7 +1278,6 @@ + // that we only instantiate the global handlers when they + // are first needed. + private class RootLogger extends Logger { +- + private RootLogger() { + super("", null); + setLevel(defaultLevel); +diff --git a/src/share/classes/java/util/logging/Logger.java b/src/share/classes/java/util/logging/Logger.java +--- openjdk/jdk/src/share/classes/java/util/logging/Logger.java ++++ openjdk/jdk/src/share/classes/java/util/logging/Logger.java +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it +@@ -29,7 +29,6 @@ + import java.util.*; + import java.security.*; + import java.lang.ref.WeakReference; +-import java.util.logging.LogManager.LoggerContext; + + /** + * A Logger object is used to log messages for a specific +@@ -283,18 +282,32 @@ + // + // As an interim solution, if the immediate caller whose caller loader is + // null, we assume it's a system logger and add it to the system context. +- private static LoggerContext getLoggerContext() { ++ // These system loggers only set the resource bundle to the given ++ // resource bundle name (rather than the default system resource bundle). ++ private static class SystemLoggerHelper { ++ static boolean disableCallerCheck = getBooleanProperty("sun.util.logging.disableCallerCheck"); ++ private static boolean getBooleanProperty(final String key) { ++ String s = AccessController.doPrivileged(new PrivilegedAction<String>() { ++ public String run() { ++ return System.getProperty(key); ++ } ++ }); ++ return Boolean.valueOf(s); ++ } ++ } ++ ++ private static Logger demandLogger(String name, String resourceBundleName) { + LogManager manager = LogManager.getLogManager(); + SecurityManager sm = System.getSecurityManager(); +- if (sm != null) { ++ if (sm != null && !SystemLoggerHelper.disableCallerCheck) { + // 0: Reflection 1: Logger.getLoggerContext 2: Logger.getLogger 3: caller + final int SKIP_FRAMES = 3; + Class<?> caller = sun.reflect.Reflection.getCallerClass(SKIP_FRAMES); + if (caller.getClassLoader() == null) { +- return manager.getSystemContext(); ++ return manager.demandSystemLogger(name, resourceBundleName); + } + } +- return manager.getUserContext(); ++ return manager.demandLogger(name, resourceBundleName); + } + + /** +@@ -325,8 +338,7 @@ + * @throws NullPointerException if the name is null. + */ + public static synchronized Logger getLogger(String name) { +- LoggerContext context = getLoggerContext(); +- return context.demandLogger(name); ++ return demandLogger(name, null); + } + + /** +@@ -369,8 +381,7 @@ + * @throws NullPointerException if the name is null. + */ + public static synchronized Logger getLogger(String name, String resourceBundleName) { +- LoggerContext context = getLoggerContext(); +- Logger result = context.demandLogger(name, resourceBundleName); ++ Logger result = demandLogger(name, resourceBundleName); + if (result.resourceBundleName == null) { + // Note: we may get a MissingResourceException here. + result.setupResourceInfo(resourceBundleName); +@@ -1300,7 +1311,8 @@ + public ResourceBundle run() { + try { + return ResourceBundle.getBundle(SYSTEM_LOGGER_RB_NAME, +- locale); ++ locale, ++ ClassLoader.getSystemClassLoader()); + } catch (MissingResourceException e) { + throw new InternalError(e.toString()); + }