/hg/icedtea6: S7122142: (ann) Race condition between isAnnotatio...
andrew at icedtea.classpath.org
andrew at icedtea.classpath.org
Thu Oct 2 21:51:17 UTC 2014
changeset 251d55dd9268 in /hg/icedtea6
details: http://icedtea.classpath.org/hg/icedtea6?cmd=changeset;node=251d55dd9268
author: Andrew John Hughes <gnu.andrew at redhat.com>
date: Thu Oct 02 22:50:54 2014 +0100
S7122142: (ann) Race condition between isAnnotationPresent and getAnnotations
2014-10-02 Andrew John Hughes <gnu.andrew at redhat.com>
* Makefile.am:
(ICEDTEA_PATCHES): Add new patch.
* NEWS: Updated.
* patches/openjdk/7122142-annotation_race_condition.patch:
Backport fix for annotation race condition.
diffstat:
ChangeLog | 8 +
Makefile.am | 3 +-
NEWS | 1 +
patches/openjdk/7122142-annotation_race_condition.patch | 1953 +++++++++++++++
4 files changed, 1964 insertions(+), 1 deletions(-)
diffs (truncated from 1996 to 500 lines):
diff -r b83d551f7874 -r 251d55dd9268 ChangeLog
--- a/ChangeLog Wed Jul 30 17:26:41 2014 +0100
+++ b/ChangeLog Thu Oct 02 22:50:54 2014 +0100
@@ -1,3 +1,11 @@
+2014-10-02 Andrew John Hughes <gnu.andrew at redhat.com>
+
+ * Makefile.am:
+ (ICEDTEA_PATCHES): Add new patch.
+ * NEWS: Updated.
+ * patches/openjdk/7122142-annotation_race_condition.patch:
+ Backport fix for annotation race condition.
+
2014-07-30 Andrew John Hughes <gnu.andrew at redhat.com>
PR1886: IcedTea does not checksum supplied tarballs
diff -r b83d551f7874 -r 251d55dd9268 Makefile.am
--- a/Makefile.am Wed Jul 30 17:26:41 2014 +0100
+++ b/Makefile.am Thu Oct 02 22:50:54 2014 +0100
@@ -617,7 +617,8 @@
patches/openjdk/6611637-npe_in_glyphlayout.patch \
patches/openjdk/6727719-performance_of_textlayout_getbounds.patch \
patches/openjdk/6745225-memory_leak_in_attributed_string.patch \
- patches/openjdk/oj639-handle_fonts_with_no_canon_flag_set.patch
+ patches/openjdk/oj639-handle_fonts_with_no_canon_flag_set.patch \
+ patches/openjdk/7122142-annotation_race_condition.patch
if WITH_RHINO
ICEDTEA_PATCHES += \
diff -r b83d551f7874 -r 251d55dd9268 NEWS
--- a/NEWS Wed Jul 30 17:26:41 2014 +0100
+++ b/NEWS Thu Oct 02 22:50:54 2014 +0100
@@ -19,6 +19,7 @@
- S6727719: Performance of TextLayout.getBounds()
- S6745225: Memory leak while drawing Attributed String
- S6904962: GlyphVector.getVisualBounds should not be affected by leading or trailing white space.
+ - S7122142: (ann) Race condition between isAnnotationPresent and getAnnotations
- S7151089: PS NUMA: NUMA allocator should not attempt to free pages when using SHM large pages
- S8013057: Detect mmap() commit failures in Linux and Solaris os::commit_memory() impls and call vm_exit_out_of_memory()
- S8026887: Make issues due to failed large pages allocations easier to debug
diff -r b83d551f7874 -r 251d55dd9268 patches/openjdk/7122142-annotation_race_condition.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/7122142-annotation_race_condition.patch Thu Oct 02 22:50:54 2014 +0100
@@ -0,0 +1,1953 @@
+diff -r d1f592073a0e src/share/classes/java/lang/Class.java
+--- openjdk/jdk/src/share/classes/java/lang/Class.java Fri Sep 12 22:39:32 2014 +0100
++++ openjdk/jdk/src/share/classes/java/lang/Class.java Thu Oct 02 20:18:56 2014 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
++ * Copyright (c) 1994, 2014, 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
+@@ -271,7 +271,7 @@
+ }
+
+ /** Called after security checks have been made. */
+- private static native Class forName0(String name, boolean initialize,
++ private static native Class<?> forName0(String name, boolean initialize,
+ ClassLoader loader)
+ throws ClassNotFoundException;
+
+@@ -341,15 +341,15 @@
+ );
+ }
+ try {
+- Class[] empty = {};
++ Class<?>[] empty = {};
+ final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
+ // Disable accessibility checks on the constructor
+ // since we have to do the security check here anyway
+ // (the stack depth is wrong for the Constructor's
+ // security check to work)
+- java.security.AccessController.doPrivileged
+- (new java.security.PrivilegedAction() {
+- public Object run() {
++ java.security.AccessController.doPrivileged(
++ new java.security.PrivilegedAction<Void>() {
++ public Void run() {
+ c.setAccessible(true);
+ return null;
+ }
+@@ -379,7 +379,7 @@
+ }
+ }
+ private volatile transient Constructor<T> cachedConstructor;
+- private volatile transient Class newInstanceCallerCache;
++ private volatile transient Class<?> newInstanceCallerCache;
+
+
+ /**
+@@ -637,7 +637,7 @@
+ if (getGenericSignature() != null)
+ return (TypeVariable<Class<T>>[])getGenericInfo().getTypeParameters();
+ else
+- return (TypeVariable<Class<T>>[])new TypeVariable[0];
++ return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
+ }
+
+
+@@ -901,7 +901,7 @@
+
+ MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(),
+ getFactory());
+- Class returnType = toClass(typeInfo.getReturnType());
++ Class<?> returnType = toClass(typeInfo.getReturnType());
+ Type [] parameterTypes = typeInfo.getParameterTypes();
+ Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
+
+@@ -1005,12 +1005,12 @@
+
+ }
+
+- private static Class toClass(Type o) {
++ private static Class<?> toClass(Type o) {
+ if (o instanceof GenericArrayType)
+ return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),
+ 0)
+ .getClass();
+- return (Class)o;
++ return (Class<?>)o;
+ }
+
+ /**
+@@ -1340,13 +1340,13 @@
+ // out anything other than public members and (2) public member access
+ // has already been ok'd by the SecurityManager.
+
+- Class[] result = (Class[]) java.security.AccessController.doPrivileged
+- (new java.security.PrivilegedAction() {
+- public Object run() {
+- java.util.List<Class> list = new java.util.ArrayList();
+- Class currentClass = Class.this;
++ return java.security.AccessController.doPrivileged(
++ new java.security.PrivilegedAction<Class<?>[]>() {
++ public Class[] run() {
++ List<Class<?>> list = new ArrayList<Class<?>>();
++ Class<?> currentClass = Class.this;
+ while (currentClass != null) {
+- Class[] members = currentClass.getDeclaredClasses();
++ Class<?>[] members = currentClass.getDeclaredClasses();
+ for (int i = 0; i < members.length; i++) {
+ if (Modifier.isPublic(members[i].getModifiers())) {
+ list.add(members[i]);
+@@ -1354,12 +1354,9 @@
+ }
+ currentClass = currentClass.getSuperclass();
+ }
+- Class[] empty = {};
+- return list.toArray(empty);
++ return list.toArray(new Class[0]);
+ }
+ });
+-
+- return result;
+ }
+
+
+@@ -2283,7 +2280,7 @@
+ return name;
+ }
+ if (!name.startsWith("/")) {
+- Class c = this;
++ Class<?> c = this;
+ while (c.isArray()) {
+ c = c.getComponentType();
+ }
+@@ -2300,44 +2297,111 @@
+ }
+
+ /**
++ * Atomic operations support.
++ */
++ private static class Atomic {
++ // initialize Unsafe machinery here, since we need to call Class.class instance method
++ // and have to avoid calling it in the static initializer of the Class class...
++ private static final Unsafe unsafe = Unsafe.getUnsafe();
++ // offset of Class.reflectionData instance field
++ private static final long reflectionDataOffset;
++ // offset of Class.annotationType instance field
++ private static final long annotationTypeOffset;
++
++ static {
++ Field[] fields = Class.class.getDeclaredFields0(false); // bypass caches
++ reflectionDataOffset = objectFieldOffset(fields, "reflectionData");
++ annotationTypeOffset = objectFieldOffset(fields, "annotationType");
++ }
++
++ private static long objectFieldOffset(Field[] fields, String fieldName) {
++ Field field = searchFields(fields, fieldName);
++ if (field == null) {
++ throw new Error("No " + fieldName + " field found in java.lang.Class");
++ }
++ return unsafe.objectFieldOffset(field);
++ }
++
++ static <T> boolean casReflectionData(Class<?> clazz,
++ SoftReference<ReflectionData<T>> oldData,
++ SoftReference<ReflectionData<T>> newData) {
++ return unsafe.compareAndSwapObject(clazz, reflectionDataOffset, oldData, newData);
++ }
++
++ static <T> boolean casAnnotationType(Class<?> clazz,
++ AnnotationType oldType,
++ AnnotationType newType) {
++ return unsafe.compareAndSwapObject(clazz, annotationTypeOffset, oldType, newType);
++ }
++ }
++
++ /**
+ * Reflection support.
+ */
+
+ // Caches for certain reflective results
+ private static boolean useCaches = true;
+- private volatile transient SoftReference declaredFields;
+- private volatile transient SoftReference publicFields;
+- private volatile transient SoftReference declaredMethods;
+- private volatile transient SoftReference publicMethods;
+- private volatile transient SoftReference declaredConstructors;
+- private volatile transient SoftReference publicConstructors;
+- // Intermediate results for getFields and getMethods
+- private volatile transient SoftReference declaredPublicFields;
+- private volatile transient SoftReference declaredPublicMethods;
++
++ // reflection data that might get invalidated when JVM TI RedefineClasses() is called
++ static class ReflectionData<T> {
++ volatile Field[] declaredFields;
++ volatile Field[] publicFields;
++ volatile Method[] declaredMethods;
++ volatile Method[] publicMethods;
++ volatile Constructor<T>[] declaredConstructors;
++ volatile Constructor<T>[] publicConstructors;
++ // Intermediate results for getFields and getMethods
++ volatile Field[] declaredPublicFields;
++ volatile Method[] declaredPublicMethods;
++ // Value of classRedefinedCount when we created this ReflectionData instance
++ final int redefinedCount;
++
++ ReflectionData(int redefinedCount) {
++ this.redefinedCount = redefinedCount;
++ }
++ }
++
++ private volatile transient SoftReference<ReflectionData<T>> reflectionData;
+
+ // Incremented by the VM on each call to JVM TI RedefineClasses()
+ // that redefines this class or a superclass.
+ private volatile transient int classRedefinedCount = 0;
+
+- // Value of classRedefinedCount when we last cleared the cached values
+- // that are sensitive to class redefinition.
+- private volatile transient int lastRedefinedCount = 0;
++ // Lazily create and cache ReflectionData
++ private ReflectionData<T> reflectionData() {
++ SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
++ int classRedefinedCount = this.classRedefinedCount;
++ ReflectionData<T> rd;
++ if (useCaches &&
++ reflectionData != null &&
++ (rd = reflectionData.get()) != null &&
++ rd.redefinedCount == classRedefinedCount) {
++ return rd;
++ }
++ // else no SoftReference or cleared SoftReference or stale ReflectionData
++ // -> create and replace new instance
++ return newReflectionData(reflectionData, classRedefinedCount);
++ }
+
+- // Clears cached values that might possibly have been obsoleted by
+- // a class redefinition.
+- private void clearCachesOnClassRedefinition() {
+- if (lastRedefinedCount != classRedefinedCount) {
+- declaredFields = publicFields = declaredPublicFields = null;
+- declaredMethods = publicMethods = declaredPublicMethods = null;
+- declaredConstructors = publicConstructors = null;
+- annotations = declaredAnnotations = null;
++ private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> oldReflectionData,
++ int classRedefinedCount) {
++ if (!useCaches) return null;
+
+- // Use of "volatile" (and synchronization by caller in the case
+- // of annotations) ensures that no thread sees the update to
+- // lastRedefinedCount before seeing the caches cleared.
+- // We do not guard against brief windows during which multiple
+- // threads might redundantly work to fill an empty cache.
+- lastRedefinedCount = classRedefinedCount;
++ while (true) {
++ ReflectionData<T> rd = new ReflectionData<T>(classRedefinedCount);
++ // try to CAS it...
++ if (Atomic.casReflectionData(this, oldReflectionData,
++ new SoftReference<ReflectionData<T>>(rd))) {
++ return rd;
++ }
++ // else retry
++ oldReflectionData = this.reflectionData;
++ classRedefinedCount = this.classRedefinedCount;
++ if (oldReflectionData != null &&
++ (rd = oldReflectionData.get()) != null &&
++ rd.redefinedCount == classRedefinedCount) {
++ return rd;
++ }
+ }
+ }
+
+@@ -2365,7 +2429,7 @@
+ }
+
+ // Annotations handling
+- private native byte[] getRawAnnotations();
++ native byte[] getRawAnnotations();
+
+ native ConstantPool getConstantPool();
+
+@@ -2380,27 +2444,19 @@
+ // via ReflectionFactory.copyField.
+ private Field[] privateGetDeclaredFields(boolean publicOnly) {
+ checkInitted();
+- Field[] res = null;
+- if (useCaches) {
+- clearCachesOnClassRedefinition();
+- if (publicOnly) {
+- if (declaredPublicFields != null) {
+- res = (Field[]) declaredPublicFields.get();
+- }
+- } else {
+- if (declaredFields != null) {
+- res = (Field[]) declaredFields.get();
+- }
+- }
++ Field[] res;
++ ReflectionData<T> rd = reflectionData();
++ if (rd != null) {
++ res = publicOnly ? rd.declaredPublicFields : rd.declaredFields;
+ if (res != null) return res;
+ }
+ // No cached value available; request value from VM
+ res = Reflection.filterFields(this, getDeclaredFields0(publicOnly));
+- if (useCaches) {
++ if (rd != null) {
+ if (publicOnly) {
+- declaredPublicFields = new SoftReference(res);
++ rd.declaredPublicFields = res;
+ } else {
+- declaredFields = new SoftReference(res);
++ rd.declaredFields = res;
+ }
+ }
+ return res;
+@@ -2409,22 +2465,20 @@
+ // Returns an array of "root" fields. These Field objects must NOT
+ // be propagated to the outside world, but must instead be copied
+ // via ReflectionFactory.copyField.
+- private Field[] privateGetPublicFields(Set traversedInterfaces) {
++ private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces) {
+ checkInitted();
+- Field[] res = null;
+- if (useCaches) {
+- clearCachesOnClassRedefinition();
+- if (publicFields != null) {
+- res = (Field[]) publicFields.get();
+- }
++ Field[] res;
++ ReflectionData<T> rd = reflectionData();
++ if (rd != null) {
++ res = rd.publicFields;
+ if (res != null) return res;
+ }
+
+ // No cached value available; compute value recursively.
+ // Traverse in correct order for getField().
+- List fields = new ArrayList();
++ List<Field> fields = new ArrayList<Field>();
+ if (traversedInterfaces == null) {
+- traversedInterfaces = new HashSet();
++ traversedInterfaces = new HashSet<Class<?>>();
+ }
+
+ // Local fields
+@@ -2432,9 +2486,7 @@
+ addAll(fields, tmp);
+
+ // Direct superinterfaces, recursively
+- Class[] interfaces = getInterfaces();
+- for (int i = 0; i < interfaces.length; i++) {
+- Class c = interfaces[i];
++ for (Class<?> c : getInterfaces()) {
+ if (!traversedInterfaces.contains(c)) {
+ traversedInterfaces.add(c);
+ addAll(fields, c.privateGetPublicFields(traversedInterfaces));
+@@ -2443,7 +2495,7 @@
+
+ // Direct superclass, recursively
+ if (!isInterface()) {
+- Class c = getSuperclass();
++ Class<?> c = getSuperclass();
+ if (c != null) {
+ addAll(fields, c.privateGetPublicFields(traversedInterfaces));
+ }
+@@ -2451,13 +2503,13 @@
+
+ res = new Field[fields.size()];
+ fields.toArray(res);
+- if (useCaches) {
+- publicFields = new SoftReference(res);
++ if (rd != null) {
++ rd.publicFields = res;
+ }
+ return res;
+ }
+
+- private static void addAll(Collection c, Field[] o) {
++ private static void addAll(Collection<Field> c, Field[] o) {
+ for (int i = 0; i < o.length; i++) {
+ c.add(o[i]);
+ }
+@@ -2473,20 +2525,12 @@
+ // Returns an array of "root" constructors. These Constructor
+ // objects must NOT be propagated to the outside world, but must
+ // instead be copied via ReflectionFactory.copyConstructor.
+- private Constructor[] privateGetDeclaredConstructors(boolean publicOnly) {
++ private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
+ checkInitted();
+- Constructor[] res = null;
+- if (useCaches) {
+- clearCachesOnClassRedefinition();
+- if (publicOnly) {
+- if (publicConstructors != null) {
+- res = (Constructor[]) publicConstructors.get();
+- }
+- } else {
+- if (declaredConstructors != null) {
+- res = (Constructor[]) declaredConstructors.get();
+- }
+- }
++ Constructor<T>[] res;
++ ReflectionData<T> rd = reflectionData();
++ if (rd != null) {
++ res = publicOnly ? rd.publicConstructors : rd.declaredConstructors;
+ if (res != null) return res;
+ }
+ // No cached value available; request value from VM
+@@ -2495,11 +2539,11 @@
+ } else {
+ res = getDeclaredConstructors0(publicOnly);
+ }
+- if (useCaches) {
++ if (rd != null) {
+ if (publicOnly) {
+- publicConstructors = new SoftReference(res);
++ rd.publicConstructors = res;
+ } else {
+- declaredConstructors = new SoftReference(res);
++ rd.declaredConstructors = res;
+ }
+ }
+ return res;
+@@ -2516,27 +2560,19 @@
+ // via ReflectionFactory.copyMethod.
+ private Method[] privateGetDeclaredMethods(boolean publicOnly) {
+ checkInitted();
+- Method[] res = null;
+- if (useCaches) {
+- clearCachesOnClassRedefinition();
+- if (publicOnly) {
+- if (declaredPublicMethods != null) {
+- res = (Method[]) declaredPublicMethods.get();
+- }
+- } else {
+- if (declaredMethods != null) {
+- res = (Method[]) declaredMethods.get();
+- }
+- }
++ Method[] res;
++ ReflectionData<T> rd = reflectionData();
++ if (rd != null) {
++ res = publicOnly ? rd.declaredPublicMethods : rd.declaredMethods;
+ if (res != null) return res;
+ }
+ // No cached value available; request value from VM
+ res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));
+- if (useCaches) {
++ if (rd != null) {
+ if (publicOnly) {
+- declaredPublicMethods = new SoftReference(res);
++ rd.declaredPublicMethods = res;
+ } else {
+- declaredMethods = new SoftReference(res);
++ rd.declaredMethods = res;
+ }
+ }
+ return res;
+@@ -2638,12 +2674,10 @@
+ // via ReflectionFactory.copyMethod.
+ private Method[] privateGetPublicMethods() {
+ checkInitted();
+- Method[] res = null;
+- if (useCaches) {
+- clearCachesOnClassRedefinition();
+- if (publicMethods != null) {
More information about the distro-pkg-dev
mailing list