/hg/release/icedtea6-1.12: 3 new changesets
andrew at icedtea.classpath.org
andrew at icedtea.classpath.org
Fri Feb 8 05:32:09 PST 2013
changeset b5896cd86594 in /hg/release/icedtea6-1.12
details: http://icedtea.classpath.org/hg/release/icedtea6-1.12?cmd=changeset;node=b5896cd86594
author: Andrew John Hughes <gnu.andrew at redhat.com>
date: Fri Feb 08 12:46:19 2013 +0000
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 at 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.
* NEWS: Updated.
changeset 6dc96601d653 in /hg/release/icedtea6-1.12
details: http://icedtea.classpath.org/hg/release/icedtea6-1.12?cmd=changeset;node=6dc96601d653
author: Andrew John Hughes <gnu.andrew at redhat.com>
date: Fri Feb 08 13:00:04 2013 +0000
PR1297: cacao and jamvm parallel unpack failures
2013-02-08 Andrew John Hughes <gnu.andrew at redhat.com>
PR1297: cacao and jamvm parallel unpack failures
* Makefile.am:
Add aliases for extract-cacao and extract-jamvm.
(extract-cacao): Depend on download-cacao.
(extract-jamvm): Depend on download-jamvm.
* NEWS: Updated.
changeset 4a6f2eb69167 in /hg/release/icedtea6-1.12
details: http://icedtea.classpath.org/hg/release/icedtea6-1.12?cmd=changeset;node=4a6f2eb69167
author: Andrew John Hughes <gnu.andrew at redhat.com>
date: Fri Feb 08 13:31:03 2013 +0000
PR1301: PR1171 causes Zero builds to fail
2013-02-08 Andrew John Hughes <gnu.andrew at redhat.com>
PR1301: PR1171 causes Zero builds to fail
(add-archive): Don't run -Xshare:dump if building
Zero.
(add-archive-debug): Likewise.
(add-archive-ecj): Likewise.
diffstat:
ChangeLog | 29 +
Makefile.am | 18 +-
NEWS | 7 +
patches/openjdk/8004341-jck_dialog_failure.patch | 19 +
patches/openjdk/8005615-failure_to_load_logger_implementation.patch | 542 ++++++++++
5 files changed, 612 insertions(+), 3 deletions(-)
diffs (truncated from 709 to 500 lines):
diff -r 52124c9776fb -r 4a6f2eb69167 ChangeLog
--- a/ChangeLog Mon Feb 04 20:23:15 2013 -0500
+++ b/ChangeLog Fri Feb 08 13:31:03 2013 +0000
@@ -1,3 +1,32 @@
+2013-02-08 Andrew John Hughes <gnu.andrew at redhat.com>
+
+ PR1301: PR1171 causes Zero builds to fail
+ (add-archive): Don't run -Xshare:dump if building
+ Zero.
+ (add-archive-debug): Likewise.
+ (add-archive-ecj): Likewise.
+
+2013-02-08 Andrew John Hughes <gnu.andrew at redhat.com>
+
+ PR1297: cacao and jamvm parallel unpack failures
+ * Makefile.am:
+ Add aliases for extract-cacao and extract-jamvm.
+ (extract-cacao): Depend on download-cacao.
+ (extract-jamvm): Depend on download-jamvm.
+ * NEWS: Updated.
+
+2013-02-08 Andrew John Hughes <gnu.andrew at 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.
+ * NEWS: Updated.
+
2013-02-04 Omair Majid <omajid at redhat.com>
* NEWS: Fix release date of 1.12.1. Add new section.
diff -r 52124c9776fb -r 4a6f2eb69167 Makefile.am
--- a/Makefile.am Mon Feb 04 20:23:15 2013 -0500
+++ b/Makefile.am Fri Feb 08 13:31: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 += \
@@ -1128,7 +1130,7 @@
rm -f stamps/patch-fsg.stamp
rm -f stamps/patch.stamp
-stamps/extract-cacao.stamp:
+stamps/extract-cacao.stamp: stamps/download-cacao.stamp
if BUILD_CACAO
if !USE_SYSTEM_CACAO
if USE_ALT_CACAO_SRC_DIR
@@ -1153,7 +1155,7 @@
mkdir -p stamps
touch $@
-stamps/extract-jamvm.stamp:
+stamps/extract-jamvm.stamp: stamps/download-jamvm.stamp
if BUILD_JAMVM
set -e ; \
if ! test -d jamvm ; \
@@ -1866,11 +1868,13 @@
stamps/add-archive.stamp: stamps/icedtea.stamp
if !ENABLE_JAMVM
if !ENABLE_CACAO
+if !ZERO_BUILD
if [ -e $(BUILD_OUTPUT_DIR)/j2sdk-image/bin/java ] ; then \
$(BUILD_OUTPUT_DIR)/j2sdk-image/bin/java -Xshare:dump ; \
fi
endif
endif
+endif
touch stamps/add-archive.stamp
clean-add-archive:
@@ -1880,11 +1884,13 @@
stamps/add-archive-debug.stamp: stamps/icedtea-debug.stamp
if !ENABLE_JAMVM
if !ENABLE_CACAO
+if !ZERO_BUILD
if [ -e $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/bin/java ] ; then \
$(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/bin/java -Xshare:dump ; \
fi
endif
endif
+endif
touch stamps/add-archive-debug.stamp
clean-add-archive-debug:
@@ -2061,11 +2067,13 @@
stamps/add-archive-ecj.stamp: stamps/icedtea-ecj.stamp
if !ENABLE_JAMVM
if !ENABLE_CACAO
+if !ZERO_BUILD
if [ -e $(ECJ_BUILD_OUTPUT_DIR)/j2sdk-image/bin/java ] ; then \
$(ECJ_BUILD_OUTPUT_DIR)/j2sdk-image/bin/java -Xshare:dump ; \
fi
endif
endif
+endif
touch stamps/add-archive-ecj.stamp
clean-add-archive-ecj:
@@ -2710,8 +2718,12 @@
extract: stamps/extract.stamp
+extract-cacao: stamps/extract-cacao.stamp
+
extract-ecj: stamps/extract-ecj.stamp
+extract-jamvm: stamps/extract-jamvm.stamp
+
hotspot-ports: stamps/ports.stamp
icedtea: stamps/icedtea.stamp
diff -r 52124c9776fb -r 4a6f2eb69167 NEWS
--- a/NEWS Mon Feb 04 20:23:15 2013 -0500
+++ b/NEWS Fri Feb 08 13:31:03 2013 +0000
@@ -12,6 +12,13 @@
New in release 1.12.2 (2013-XX-YY):
+* Backports
+ - S8004341: Two JCK tests fails with 7u11 b06
+ - S8005615: Java Logger fails to load tomcat logger implementation (JULI)
+* Bug fixes
+ - PR1297: cacao and jamvm parallel unpack failures
+ - PR1301: PR1171 causes builds of Zero to fail
+
New in release 1.12.1 (2013-02-04):
* Security fixes
diff -r 52124c9776fb -r 4a6f2eb69167 patches/openjdk/8004341-jck_dialog_failure.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/8004341-jck_dialog_failure.patch Fri Feb 08 13:31:03 2013 +0000
@@ -0,0 +1,19 @@
+# HG changeset patch
+# User andrew
+# Date 1360323180 0
+# Node ID ca6ee539c5f4f4dd9d5fb9b0604d94c5806c3e28
+# Parent 635d562a25becae602dc5988dae8bce84b199eb4
+8004341: Two JCK tests fails with 7u11 b06
+
+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
+@@ -1636,6 +1636,8 @@
+ if (localModalityType == null) {
+ this.modal = fields.get("modal", false);
+ setModal(modal);
++ } else {
++ this.modalityType = localModalityType;
+ }
+
+ this.resizable = fields.get("resizable", true);
diff -r 52124c9776fb -r 4a6f2eb69167 patches/openjdk/8005615-failure_to_load_logger_implementation.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/8005615-failure_to_load_logger_implementation.patch Fri Feb 08 13:31: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;
More information about the distro-pkg-dev
mailing list