changeset 7883:d4bd8bd71ca7 jdk7u80-b05

Merge
author asaha
date Fri, 16 Jan 2015 13:34:22 -0800
parents 238f0af20f18 1c3c47064b5c
children 70e3553d9d6e
files
diffstat 17 files changed, 627 insertions(+), 82 deletions(-) [+]
line wrap: on
line diff
--- a/make/java/zip/Makefile	Wed Jan 07 12:34:11 2015 -0800
+++ b/make/java/zip/Makefile	Fri Jan 16 13:34:22 2015 -0800
@@ -68,6 +68,16 @@
     FILES_reorder += reorder-$(ARCH)
   endif
 endif
+
+#
+# Use mapfile unconditionally (even with fastdebug).
+# JDK's internal zlib is incompatible with stock zlib, because the
+# size of struct z_stream has been changed, so internal zlib
+# implementation must not be allowed to leak outside of libzip.so,
+# else you get hard to debug failures with fastdebug jdk when user
+# native code includes stock zlib.
+#
+FILES_m = mapfile-vers
 include $(BUILDDIR)/common/Mapfile-vers.gmk
 include $(BUILDDIR)/common/Library.gmk
 
--- a/src/share/classes/sun/management/jmxremote/ConnectorBootstrap.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/classes/sun/management/jmxremote/ConnectorBootstrap.java	Fri Jan 16 13:34:22 2015 -0800
@@ -777,7 +777,7 @@
                     JMXConnectorServerFactory.newJMXConnectorServer(url, env, mbs);
             connServer.start();
         } catch (IOException e) {
-            if (connServer == null) {
+            if (connServer == null || connServer.getAddress() == null) {
                 throw new AgentConfigurationError(CONNECTOR_SERVER_IO_ERROR,
                         e, url.toString());
             } else {
--- a/src/share/classes/sun/nio/ch/FileChannelImpl.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/classes/sun/nio/ch/FileChannelImpl.java	Fri Jan 16 13:34:22 2015 -0800
@@ -397,30 +397,13 @@
     //
     private static volatile boolean fileSupported = true;
 
-    private long transferToDirectly(long position, int icount,
-                                    WritableByteChannel target)
+    private long transferToDirectlyInternal(long position, int icount,
+                                            WritableByteChannel target,
+                                            FileDescriptor targetFD)
         throws IOException
     {
-        if (!transferSupported)
-            return IOStatus.UNSUPPORTED;
-
-        FileDescriptor targetFD = null;
-        if (target instanceof FileChannelImpl) {
-            if (!fileSupported)
-                return IOStatus.UNSUPPORTED_CASE;
-            targetFD = ((FileChannelImpl)target).fd;
-        } else if (target instanceof SelChImpl) {
-            // Direct transfer to pipe causes EINVAL on some configurations
-            if ((target instanceof SinkChannelImpl) && !pipeSupported)
-                return IOStatus.UNSUPPORTED_CASE;
-            targetFD = ((SelChImpl)target).getFD();
-        }
-        if (targetFD == null)
-            return IOStatus.UNSUPPORTED;
-        int thisFDVal = IOUtil.fdVal(fd);
-        int targetFDVal = IOUtil.fdVal(targetFD);
-        if (thisFDVal == targetFDVal) // Not supported on some configurations
-            return IOStatus.UNSUPPORTED;
+        assert !nd.transferToDirectlyNeedsPositionLock() ||
+               Thread.holdsLock(positionLock);
 
         long n = -1;
         int ti = -1;
@@ -430,7 +413,7 @@
             if (!isOpen())
                 return -1;
             do {
-                n = transferTo0(thisFDVal, position, icount, targetFDVal);
+                n = transferTo0(fd, position, icount, targetFD);
             } while ((n == IOStatus.INTERRUPTED) && isOpen());
             if (n == IOStatus.UNSUPPORTED_CASE) {
                 if (target instanceof SinkChannelImpl)
@@ -451,6 +434,54 @@
         }
     }
 
+    private long transferToDirectly(long position, int icount,
+                                    WritableByteChannel target)
+        throws IOException
+    {
+        if (!transferSupported)
+            return IOStatus.UNSUPPORTED;
+
+        FileDescriptor targetFD = null;
+        if (target instanceof FileChannelImpl) {
+            if (!fileSupported)
+                return IOStatus.UNSUPPORTED_CASE;
+            targetFD = ((FileChannelImpl)target).fd;
+        } else if (target instanceof SelChImpl) {
+            // Direct transfer to pipe causes EINVAL on some configurations
+            if ((target instanceof SinkChannelImpl) && !pipeSupported)
+                return IOStatus.UNSUPPORTED_CASE;
+
+            // Platform-specific restrictions. Now there is only one:
+            // Direct transfer to non-blocking channel could be forbidden
+            SelectableChannel sc = (SelectableChannel)target;
+            if (!nd.canTransferToDirectly(sc))
+                return IOStatus.UNSUPPORTED_CASE;
+
+            targetFD = ((SelChImpl)target).getFD();
+        }
+
+        if (targetFD == null)
+            return IOStatus.UNSUPPORTED;
+        int thisFDVal = IOUtil.fdVal(fd);
+        int targetFDVal = IOUtil.fdVal(targetFD);
+        if (thisFDVal == targetFDVal) // Not supported on some configurations
+            return IOStatus.UNSUPPORTED;
+
+        if (nd.transferToDirectlyNeedsPositionLock()) {
+            synchronized (positionLock) {
+                long pos = position();
+                try {
+                    return transferToDirectlyInternal(position, icount,
+                                                      target, targetFD);
+                } finally {
+                    position(pos);
+                }
+            }
+        } else {
+            return transferToDirectlyInternal(position, icount, target, targetFD);
+        }
+    }
+
     // Maximum size to map when using a mapped buffer
     private static final long MAPPED_TRANSFER_SIZE = 8L*1024L*1024L;
 
@@ -1157,7 +1188,8 @@
     private static native int unmap0(long address, long length);
 
     // Transfers from src to dst, or returns -2 if kernel can't do that
-    private native long transferTo0(int src, long position, long count, int dst);
+    private native long transferTo0(FileDescriptor src, long position,
+                                    long count, FileDescriptor dst);
 
     // Sets or reports this file's position
     // If offset is -1, the current position is returned
--- a/src/share/classes/sun/nio/ch/FileDispatcher.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/classes/sun/nio/ch/FileDispatcher.java	Fri Jan 16 13:34:22 2015 -0800
@@ -25,7 +25,9 @@
 
 package sun.nio.ch;
 
-import java.io.*;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.channels.SelectableChannel;
 
 abstract class FileDispatcher extends NativeDispatcher {
 
@@ -53,4 +55,8 @@
      */
     abstract FileDescriptor duplicateForMapping(FileDescriptor fd)
         throws IOException;
+
+    abstract boolean canTransferToDirectly(SelectableChannel sc);
+
+    abstract boolean transferToDirectlyNeedsPositionLock();
 }
--- a/src/share/classes/sun/reflect/generics/repository/ClassRepository.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/classes/sun/reflect/generics/repository/ClassRepository.java	Fri Jan 16 13:34:22 2015 -0800
@@ -40,8 +40,11 @@
  */
 public class ClassRepository extends GenericDeclRepository<ClassSignature> {
 
-    private volatile Type superclass; // caches the generic superclass info
-    private volatile Type[] superInterfaces; // caches the generic superinterface info
+    /** The generic superclass info.  Lazily initialized. */
+    private volatile Type superclass;
+
+    /** The generic superinterface info.  Lazily initialized. */
+    private volatile Type[] superInterfaces;
 
  // private, to enforce use of static factory
     private ClassRepository(String rawSig, GenericsFactory f) {
@@ -77,7 +80,7 @@
  * with which the repository was created.
  */
 
-    public Type getSuperclass(){
+    public Type getSuperclass() {
         Type superclass = this.superclass;
         if (superclass == null) { // lazily initialize superclass
             Reifier r = getReifier(); // obtain visitor
@@ -86,25 +89,24 @@
             // extract result from visitor and cache it
             superclass = r.getResult();
             this.superclass = superclass;
-            }
+        }
         return superclass; // return cached result
     }
 
-    public Type[] getSuperInterfaces(){
+    public Type[] getSuperInterfaces() {
         Type[] superInterfaces = this.superInterfaces;
         if (superInterfaces == null) { // lazily initialize super interfaces
             // first, extract super interface subtree(s) from AST
             TypeTree[] ts  = getTree().getSuperInterfaces();
             // create array to store reified subtree(s)
-            Type[] sis = new Type[ts.length];
+            superInterfaces = new Type[ts.length];
             // reify all subtrees
             for (int i = 0; i < ts.length; i++) {
                 Reifier r = getReifier(); // obtain visitor
                 ts[i].accept(r);// reify subtree
                 // extract result from visitor and store it
-                sis[i] = r.getResult();
+                superInterfaces[i] = r.getResult();
             }
-            superInterfaces = sis; // cache overall result
             this.superInterfaces = superInterfaces;
         }
         return superInterfaces.clone(); // return cached result
--- a/src/share/classes/sun/reflect/generics/repository/GenericDeclRepository.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/classes/sun/reflect/generics/repository/GenericDeclRepository.java	Fri Jan 16 13:34:22 2015 -0800
@@ -42,7 +42,8 @@
 public abstract class GenericDeclRepository<S extends Signature>
     extends AbstractRepository<S> {
 
-    private volatile TypeVariable[] typeParams; // caches the formal type parameters
+    /** The formal type parameters.  Lazily initialized. */
+    private volatile TypeVariable[] typeParams;
 
     protected GenericDeclRepository(String rawSig, GenericsFactory f) {
         super(rawSig, f);
@@ -55,8 +56,7 @@
  * If the corresponding field is non-null, it is returned.
  * If not, it is created lazily. This is done by selecting the appropriate
  * part of the tree and transforming it into a reflective object
- * using a visitor.
- * a visitor, which is created by feeding it the factory
+ * using a visitor, which is created by feeding it the factory
  * with which the repository was created.
  */
 
@@ -64,22 +64,21 @@
      * Return the formal type parameters of this generic declaration.
      * @return the formal type parameters of this generic declaration
      */
-    public TypeVariable/*<?>*/[] getTypeParameters(){
+    public TypeVariable/*<?>*/[] getTypeParameters() {
         TypeVariable[] typeParams = this.typeParams;
         if (typeParams == null) { // lazily initialize type parameters
             // first, extract type parameter subtree(s) from AST
             FormalTypeParameter[] ftps = getTree().getFormalTypeParameters();
             // create array to store reified subtree(s)
-            TypeVariable[] tps = new TypeVariable[ftps.length];
+            typeParams = new TypeVariable[ftps.length];
             // reify all subtrees
             for (int i = 0; i < ftps.length; i++) {
                 Reifier r = getReifier(); // obtain visitor
                 ftps[i].accept(r); // reify subtree
                 // extract result from visitor and store it
-                tps[i] = (TypeVariable<?>) r.getResult();
+                typeParams[i] = (TypeVariable) r.getResult();
             }
-            typeParams = tps; // cache overall result
-            this.typeParams = typeParams;
+            this.typeParams = typeParams; // cache overall result
         }
         return typeParams.clone(); // return cached result
     }
--- a/src/share/classes/sun/reflect/generics/scope/AbstractScope.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/classes/sun/reflect/generics/scope/AbstractScope.java	Fri Jan 16 13:34:22 2015 -0800
@@ -42,7 +42,9 @@
     implements Scope {
 
     private final D recvr; // the declaration whose scope this instance represents
-    private volatile Scope enclosingScope; // the enclosing scope of this scope
+
+    /** The enclosing scope of this scope.  Lazily initialized. */
+    private volatile Scope enclosingScope;
 
     /**
      * Constructor. Takes a reflective object whose scope the newly
--- a/src/share/native/java/util/zip/Deflater.c	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/native/java/util/zip/Deflater.c	Fri Jan 16 13:34:22 2015 -0800
@@ -68,10 +68,11 @@
         JNU_ThrowOutOfMemoryError(env, 0);
         return jlong_zero;
     } else {
-        char *msg;
-        switch (deflateInit2(strm, level, Z_DEFLATED,
-                             nowrap ? -MAX_WBITS : MAX_WBITS,
-                             DEF_MEM_LEVEL, strategy)) {
+        const char *msg;
+        int ret = deflateInit2(strm, level, Z_DEFLATED,
+                               nowrap ? -MAX_WBITS : MAX_WBITS,
+                               DEF_MEM_LEVEL, strategy);
+        switch (ret) {
           case Z_OK:
             return ptr_to_jlong(strm);
           case Z_MEM_ERROR:
@@ -83,7 +84,11 @@
             JNU_ThrowIllegalArgumentException(env, 0);
             return jlong_zero;
           default:
-            msg = strm->msg;
+            msg = ((strm->msg != NULL) ? strm->msg :
+                   (ret == Z_VERSION_ERROR) ?
+                   "zlib returned Z_VERSION_ERROR: "
+                   "compile time and runtime zlib implementations differ" :
+                   "unknown error initializing zlib library");
             free(strm);
             JNU_ThrowInternalError(env, msg);
             return jlong_zero;
--- a/src/share/native/java/util/zip/Inflater.c	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/share/native/java/util/zip/Inflater.c	Fri Jan 16 13:34:22 2015 -0800
@@ -27,6 +27,7 @@
  * Native method support for java.util.zip.Inflater
  */
 
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -60,12 +61,13 @@
 {
     z_stream *strm = calloc(1, sizeof(z_stream));
 
-    if (strm == 0) {
+    if (strm == NULL) {
         JNU_ThrowOutOfMemoryError(env, 0);
         return jlong_zero;
     } else {
-        char *msg;
-        switch (inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS)) {
+        const char *msg;
+        int ret = inflateInit2(strm, nowrap ? -MAX_WBITS : MAX_WBITS);
+        switch (ret) {
           case Z_OK:
             return ptr_to_jlong(strm);
           case Z_MEM_ERROR:
@@ -73,7 +75,13 @@
             JNU_ThrowOutOfMemoryError(env, 0);
             return jlong_zero;
           default:
-            msg = strm->msg;
+            msg = ((strm->msg != NULL) ? strm->msg :
+                   (ret == Z_VERSION_ERROR) ?
+                   "zlib returned Z_VERSION_ERROR: "
+                   "compile time and runtime zlib implementations differ" :
+                   (ret == Z_STREAM_ERROR) ?
+                   "inflateInit2 returned Z_STREAM_ERROR" :
+                   "unknown error initializing zlib library");
             free(strm);
             JNU_ThrowInternalError(env, msg);
             return jlong_zero;
--- a/src/solaris/classes/sun/awt/X11/XErrorHandlerUtil.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/solaris/classes/sun/awt/X11/XErrorHandlerUtil.java	Fri Jan 16 13:34:22 2015 -0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -97,6 +97,7 @@
      * @param handler the synthetic error handler to set
      */
     public static void WITH_XERROR_HANDLER(XErrorHandler handler) {
+        XSync();
         saved_error = null;
         current_error_handler = handler;
     }
@@ -105,15 +106,9 @@
      * Unsets a current synthetic error handler. Must be called with the acquired AWT lock.
      */
     public static void RESTORE_XERROR_HANDLER() {
-        RESTORE_XERROR_HANDLER(true);
-    }
-
-    private static void RESTORE_XERROR_HANDLER(boolean doXSync) {
-        if (doXSync) {
-            // Wait until all requests are processed by the X server
-            // and only then uninstall the error handler.
-            XSync();
-        }
+        // Wait until all requests are processed by the X server
+        // and only then uninstall the error handler.
+        XSync();
         current_error_handler = null;
     }
 
--- a/src/solaris/classes/sun/nio/ch/FileDispatcherImpl.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/solaris/classes/sun/nio/ch/FileDispatcherImpl.java	Fri Jan 16 13:34:22 2015 -0800
@@ -25,10 +25,10 @@
 
 package sun.nio.ch;
 
-import java.io.*;
+import java.io.FileDescriptor;
+import java.io.IOException;
 
-class FileDispatcherImpl extends FileDispatcher
-{
+class FileDispatcherImpl extends FileDispatcher {
 
     static {
         Util.load();
@@ -108,6 +108,14 @@
         return new FileDescriptor();
     }
 
+    boolean canTransferToDirectly(java.nio.channels.SelectableChannel sc) {
+        return true;
+    }
+
+    boolean transferToDirectlyNeedsPositionLock() {
+        return false;
+    }
+
     // -- Native methods --
 
     static native int read0(FileDescriptor fd, long address, int len)
--- a/src/solaris/native/sun/nio/ch/FileChannelImpl.c	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/solaris/native/sun/nio/ch/FileChannelImpl.c	Fri Jan 16 13:34:22 2015 -0800
@@ -152,10 +152,13 @@
 
 JNIEXPORT jlong JNICALL
 Java_sun_nio_ch_FileChannelImpl_transferTo0(JNIEnv *env, jobject this,
-                                            jint srcFD,
+                                            jobject srcFDO,
                                             jlong position, jlong count,
-                                            jint dstFD)
+                                            jobject dstFDO)
 {
+    jint srcFD = fdval(env, srcFDO);
+    jint dstFD = fdval(env, dstFDO);
+
 #if defined(__linux__)
     off64_t offset = (off64_t)position;
     jlong n = sendfile64(dstFD, srcFD, &offset, (size_t)count);
--- a/src/windows/classes/sun/nio/ch/FileDispatcherImpl.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/windows/classes/sun/nio/ch/FileDispatcherImpl.java	Fri Jan 16 13:34:22 2015 -0800
@@ -25,15 +25,16 @@
 
 package sun.nio.ch;
 
-import java.io.*;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.security.PrivilegedAction;
 import sun.misc.SharedSecrets;
 import sun.misc.JavaIOFileDescriptorAccess;
 
-class FileDispatcherImpl extends FileDispatcher
-{
-    static {
-        Util.load();
-    }
+class FileDispatcherImpl extends FileDispatcher {
+
+    // set to true if fast file transmission (TransmitFile) is enabled
+    private static final boolean fastFileTransfer;
 
     /**
      * Indicates if the dispatcher should first advance the file position
@@ -120,6 +121,36 @@
         return result;
     }
 
+    boolean canTransferToDirectly(java.nio.channels.SelectableChannel sc) {
+        return fastFileTransfer && sc.isBlocking();
+    }
+
+    boolean transferToDirectlyNeedsPositionLock() {
+        return true;
+    }
+
+    static boolean isFastFileTransferRequested() {
+        String fileTransferProp = java.security.AccessController.doPrivileged(
+            new PrivilegedAction<String>() {
+                @Override
+                public String run() {
+                    return System.getProperty("jdk.nio.enableFastFileTransfer");
+                }
+            });
+        boolean enable;
+        if ("".equals(fileTransferProp)) {
+            enable = true;
+        } else {
+            enable = Boolean.parseBoolean(fileTransferProp);
+        }
+        return enable;
+    }
+
+    static {
+        Util.load();
+        fastFileTransfer = isFastFileTransferRequested();
+    }
+
     //-- Native methods
 
     static native int read0(FileDescriptor fd, long address, int len)
--- a/src/windows/native/sun/nio/ch/FileChannelImpl.c	Wed Jan 07 12:34:11 2015 -0800
+++ b/src/windows/native/sun/nio/ch/FileChannelImpl.c	Fri Jan 16 13:34:22 2015 -0800
@@ -31,6 +31,11 @@
 #include "nio.h"
 #include "nio_util.h"
 #include "sun_nio_ch_FileChannelImpl.h"
+#include "java_lang_Integer.h"
+
+#include <winsock2.h>
+#include <Mswsock.h>
+#pragma comment(lib, "Mswsock.lib")
 
 static jfieldID chan_fd; /* id for jobject 'fd' in java.io.FileChannel */
 
@@ -174,9 +179,42 @@
 
 JNIEXPORT jlong JNICALL
 Java_sun_nio_ch_FileChannelImpl_transferTo0(JNIEnv *env, jobject this,
-                                            jint srcFD,
+                                            jobject srcFD,
                                             jlong position, jlong count,
-                                            jint dstFD)
+                                            jobject dstFD)
 {
-    return IOS_UNSUPPORTED;
+    const int PACKET_SIZE = 524288;
+
+    HANDLE src = (HANDLE)(handleval(env, srcFD));
+    SOCKET dst = (SOCKET)(fdval(env, dstFD));
+    DWORD chunkSize = (count > java_lang_Integer_MAX_VALUE) ?
+        java_lang_Integer_MAX_VALUE : (DWORD)count;
+    BOOL result = 0;
+
+    jlong pos = Java_sun_nio_ch_FileChannelImpl_position0(env, this, srcFD, position);
+    if (pos == IOS_THROWN) {
+        return IOS_THROWN;
+    }
+
+    result = TransmitFile(
+        dst,
+        src,
+        chunkSize,
+        PACKET_SIZE,
+        NULL,
+        NULL,
+        TF_USE_KERNEL_APC
+    );
+    if (!result) {
+        int error = WSAGetLastError();
+        if (WSAEINVAL == error && count >= 0) {
+            return IOS_UNSUPPORTED_CASE;
+        }
+        if (WSAENOTSOCK == error) {
+            return IOS_UNSUPPORTED_CASE;
+        }
+        JNU_ThrowIOExceptionWithLastError(env, "transfer failed");
+        return IOS_THROWN;
+    }
+    return chunkSize;
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/Class/getDeclaredField/FieldSetAccessibleTest.java	Fri Jan 16 13:34:22 2015 -0800
@@ -0,0 +1,393 @@
+/*
+ * Copyright (c) 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8065552
+ * @summary test that all fields returned by getDeclaredFields() can be
+ * set accessible if the right permission is granted; this test
+ * loads all the classes in the BCL, get their declared fields,
+ * and call setAccessible(false) followed by setAccessible(true);
+ *
+ * @run main/othervm -XX:PermSize=128m FieldSetAccessibleTest UNSECURE
+ * @run main/othervm -XX:PermSize=128m FieldSetAccessibleTest SECURE
+ *
+ * @author danielfuchs
+ */
+
+import java.io.File;
+import java.io.FilePermission;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.ReflectPermission;
+import java.security.CodeSource;
+import java.security.Permission;
+import java.security.PermissionCollection;
+import java.security.Permissions;
+import java.security.Policy;
+import java.security.ProtectionDomain;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.PropertyPermission;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class FieldSetAccessibleTest {
+
+    static final List<String> skipped = new ArrayList<>();
+    static final List<String> cantread = new ArrayList<>();
+    static final List<String> failed = new ArrayList<>();
+    static final AtomicLong classCount = new AtomicLong();
+    static final AtomicLong fieldCount = new AtomicLong();
+    static long startIndex = 0;
+    static long maxSize = Long.MAX_VALUE;
+    static long maxIndex = Long.MAX_VALUE;
+
+
+    // Test that all fields for any given class can be made accessibles
+    static void testSetFieldsAccessible(Class<?> c) {
+        for (Field f : c.getDeclaredFields()) {
+            fieldCount.incrementAndGet();
+            f.setAccessible(false);
+            f.setAccessible(true);
+        }
+    }
+
+    // Performs a series of test on the given class.
+    // At this time, we only call testSetFieldsAccessible(c)
+    public static boolean test(Class<?> c) {
+        //System.out.println(c.getName());
+        classCount.incrementAndGet();
+
+        // Call getDeclaredFields() and try to set their accessible flag.
+        testSetFieldsAccessible(c);
+
+        // add more tests here...
+
+        return c == Class.class;
+    }
+
+    // Prints a summary at the end of the test.
+    static void printSummary(long secs, long millis, long nanos) {
+        System.out.println("Tested " + fieldCount.get() + " fields of "
+                + classCount.get() + " classes in "
+                + secs + "s " + millis + "ms " + nanos + "ns");
+    }
+
+    public static void main(String[] args) throws Exception {
+        TestCase.valueOf(args[0]).run();
+    }
+
+    public static void run(TestCase test) {
+        System.out.println("Testing " + test);
+        test(listAllClassNames());
+        System.out.println("Passed " + test);
+    }
+
+    static Iterable<String> listAllClassNames() {
+        boolean sort = startIndex != 0 || maxIndex != Long.MAX_VALUE;
+        return new ClassNameListBuilder(sort);
+    }
+
+    static void test(Iterable<String> iterable) {
+        final long start = System.nanoTime();
+        boolean classFound = false;
+        int index = 0;
+        for (String s: iterable) {
+            if (index == maxIndex) break;
+            try {
+                if (index < startIndex) continue;
+                if (test(s)) {
+                    classFound = true;
+                }
+            } finally {
+                index++;
+            }
+        }
+        long elapsed = System.nanoTime() - start;
+        long secs = elapsed / 1000_000_000;
+        long millis = (elapsed % 1000_000_000) / 1000_000;
+        long nanos  = elapsed % 1000_000;
+        System.out.println("Unreadable path elements: " + cantread);
+        System.out.println("Skipped path elements: " + skipped);
+        System.out.println("Failed path elements: " + failed);
+        printSummary(secs, millis, nanos);
+
+        if (!failed.isEmpty()) {
+            throw new RuntimeException("Test failed for the following classes: " + failed);
+        }
+        if (!classFound && startIndex == 0 && index < maxIndex) {
+            // this is just to verify that we have indeed parsed rt.jar
+            // (or the java.base module)
+            throw  new RuntimeException("Test failed: Class.class not found...");
+        }
+        if (classCount.get() == 0 && startIndex == 0) {
+            throw  new RuntimeException("Test failed: no class found?");
+        }
+    }
+
+    static boolean test(String s) {
+        try {
+            if (s.startsWith("WrapperGenerator")) {
+                System.out.println("Skipping "+ s);
+                return false;
+            }
+            final Class<?> c = Class.forName(
+                    s.replace('/', '.').substring(0, s.length() - 6),
+                    false,
+                    null);
+            return test(c);
+        } catch (Exception t) {
+            t.printStackTrace(System.err);
+            failed.add(s);
+        } catch (NoClassDefFoundError e) {
+            e.printStackTrace(System.err);
+            failed.add(s);
+        }
+        return false;
+    }
+
+    static class ClassNameListBuilder implements Iterable<String> {
+        String[] bcp;
+        boolean sort;
+        ClassNameListBuilder(boolean sort) {
+            bcp = System.getProperty("sun.boot.class.path").split(File.pathSeparator);
+            this.sort = sort;
+        }
+
+        public List<String> build() {
+            return findClasses();
+        }
+
+        List<String> findClasses() {
+            List<String> list = new ArrayList<>();
+
+            for (String s : bcp) {
+                System.out.println("boot class path element: " + s);
+                if (s.endsWith(".jar")) {
+                    addJarEntries(s, list);
+                } else {
+                    addFolderEntries(new File(s), s, list);
+                }
+            }
+
+            if (sort) {
+                System.out.println("Sorting class names...");
+                Collections.sort(list);
+                System.out.println("\t... Sorted.");
+            }
+            return list;
+        }
+
+        void addJarEntries(String jarName, List<String> classNames) {
+            File f = new File(jarName);
+            if (f.canRead() && f.isFile()) {
+                try {
+                    JarFile jarFile = new JarFile(f);
+                    for (Enumeration<JarEntry> entries = jarFile.entries() ; entries.hasMoreElements() ;) {
+                        JarEntry e = entries.nextElement();
+                        if (e.isDirectory()) {
+                            continue;
+                        }
+                        if (e.getName().endsWith(".class")) {
+                            classNames.add(e.getName());
+                        }
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    skipped.add(jarName);
+                }
+            } else {
+                cantread.add(jarName);
+            }
+        }
+
+        void addFolderEntries(File root, String folderName, List<String> classNames) {
+            File f = new File(folderName);
+            if (f.canRead()) {
+               if (f.isDirectory()) {
+                   for (String child :  f.list()) {
+                       addFolderEntries(root, new File(f,child).getPath(), classNames);
+                   }
+               } else if (f.isFile() && f.getName().endsWith(".class")) {
+                   String className = root.toPath().relativize(f.toPath()).toString()
+                           .replace(File.separatorChar, '/');
+                   System.out.println("adding: " + className);
+                   classNames.add(className);
+               }
+            } else {
+                cantread.add(folderName);
+            }
+        }
+
+        @Override
+        public Iterator<String> iterator() {
+            return build().iterator();
+        }
+
+    }
+
+    // Test with or without a security manager
+    public static enum TestCase {
+        UNSECURE, SECURE;
+        public void run() throws Exception {
+            System.out.println("Running test case: " + name());
+            Configure.setUp(this);
+            FieldSetAccessibleTest.run(this);
+        }
+    }
+
+    // A helper class to configure the security manager for the test,
+    // and bypass it when needed.
+    static class Configure {
+        static Policy policy = null;
+        static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
+            @Override
+            protected AtomicBoolean initialValue() {
+                return  new AtomicBoolean(false);
+            }
+        };
+        static void setUp(TestCase test) {
+            switch (test) {
+                case SECURE:
+                    if (policy == null && System.getSecurityManager() != null) {
+                        throw new IllegalStateException("SecurityManager already set");
+                    } else if (policy == null) {
+                        policy = new SimplePolicy(TestCase.SECURE, allowAll);
+                        Policy.setPolicy(policy);
+                        System.setSecurityManager(new SecurityManager());
+                    }
+                    if (System.getSecurityManager() == null) {
+                        throw new IllegalStateException("No SecurityManager.");
+                    }
+                    if (policy == null) {
+                        throw new IllegalStateException("policy not configured");
+                    }
+                    break;
+                case UNSECURE:
+                    if (System.getSecurityManager() != null) {
+                        throw new IllegalStateException("SecurityManager already set");
+                    }
+                    break;
+                default:
+                    throw new InternalError("No such testcase: " + test);
+            }
+        }
+        static void doPrivileged(Runnable run) {
+            allowAll.get().set(true);
+            try {
+                run.run();
+            } finally {
+                allowAll.get().set(false);
+            }
+        }
+    }
+
+    // A Helper class to build a set of permissions.
+    final static class PermissionsBuilder {
+        final Permissions perms;
+        public PermissionsBuilder() {
+            this(new Permissions());
+        }
+        public PermissionsBuilder(Permissions perms) {
+            this.perms = perms;
+        }
+        public PermissionsBuilder add(Permission p) {
+            perms.add(p);
+            return this;
+        }
+        public PermissionsBuilder addAll(PermissionCollection col) {
+            if (col != null) {
+                for (Enumeration<Permission> e = col.elements(); e.hasMoreElements(); ) {
+                    perms.add(e.nextElement());
+                }
+            }
+            return this;
+        }
+        public Permissions toPermissions() {
+            final PermissionsBuilder builder = new PermissionsBuilder();
+            builder.addAll(perms);
+            return builder.perms;
+        }
+    }
+
+    // Policy for the test...
+    public static class SimplePolicy extends Policy {
+
+        final Permissions permissions;
+        final Permissions allPermissions;
+        final ThreadLocal<AtomicBoolean> allowAll;
+        public SimplePolicy(TestCase test, ThreadLocal<AtomicBoolean> allowAll) {
+            this.allowAll = allowAll;
+
+            // Permission needed by the tested code exercised in the test
+            permissions = new Permissions();
+            permissions.add(new RuntimePermission("fileSystemProvider"));
+            permissions.add(new RuntimePermission("createClassLoader"));
+            permissions.add(new RuntimePermission("closeClassLoader"));
+            permissions.add(new RuntimePermission("getClassLoader"));
+            permissions.add(new RuntimePermission("accessDeclaredMembers"));
+            permissions.add(new ReflectPermission("suppressAccessChecks"));
+            permissions.add(new PropertyPermission("*", "read"));
+            permissions.add(new FilePermission("<<ALL FILES>>", "read"));
+
+            // these are used for configuring the test itself...
+            allPermissions = new Permissions();
+            allPermissions.add(new java.security.AllPermission());
+        }
+
+        @Override
+        public boolean implies(ProtectionDomain domain, Permission permission) {
+            if (allowAll.get().get()) return allPermissions.implies(permission);
+            if (permissions.implies(permission)) return true;
+            if (permission instanceof java.lang.RuntimePermission) {
+                if (permission.getName().startsWith("accessClassInPackage.")) {
+                    // add these along to the set of permission we have, when we
+                    // discover that we need them.
+                    permissions.add(permission);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override
+        public PermissionCollection getPermissions(CodeSource codesource) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+
+        @Override
+        public PermissionCollection getPermissions(ProtectionDomain domain) {
+            return new PermissionsBuilder().addAll(allowAll.get().get()
+                    ? allPermissions : permissions).toPermissions();
+        }
+    }
+
+}
--- a/test/java/lang/reflect/Method/GenericStringTest.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/test/java/lang/reflect/Method/GenericStringTest.java	Fri Jan 16 13:34:22 2015 -0800
@@ -47,10 +47,18 @@
                 if (egs != null) {
                     String actual = method.toGenericString();
                     System.out.println(actual);
-                    if (! egs.value().equals(actual)) {
-                        failures++;
-                        System.err.printf("ERROR: Expected ''%s''; got ''%s''.\n",
-                                          egs.value(), actual);
+                    if (method.isBridge()) {
+                        if (! egs.bridgeValue().equals(actual)) {
+                            failures++;
+                            System.err.printf("ERROR: Expected ''%s''; got ''%s''.\n",
+                                              egs.value(), actual);
+                        }
+                    } else {
+                        if (! egs.value().equals(actual)) {
+                            failures++;
+                            System.err.printf("ERROR: Expected ''%s''; got ''%s''.\n",
+                                              egs.value(), actual);
+                        }
                     }
                 }
 
@@ -116,7 +124,8 @@
 
 class Roebling implements Comparable<Roebling> {
     @ExpectedGenericString(
-   "public int Roebling.compareTo(Roebling)")
+    value="public int Roebling.compareTo(Roebling)",
+    bridgeValue="public int Roebling.compareTo(java.lang.Object)")
     public int compareTo(Roebling r) {
         throw new IllegalArgumentException();
     }
@@ -132,9 +141,11 @@
 @Retention(RetentionPolicy.RUNTIME)
 @interface ExpectedGenericString {
     String value();
+    String bridgeValue() default "";
 }
 
 @Retention(RetentionPolicy.RUNTIME)
 @interface ExpectedString {
     String value();
 }
+
--- a/test/java/nio/channels/FileChannel/TransferToChannel.java	Wed Jan 07 12:34:11 2015 -0800
+++ b/test/java/nio/channels/FileChannel/TransferToChannel.java	Fri Jan 16 13:34:22 2015 -0800
@@ -22,8 +22,10 @@
  */
 
 /* @test
- * @bug 4652496
+ * @bug 4652496 8064407 8068507
  * @summary Test transferTo with different target channels
+ * @run main TransferToChannel
+ * @run main/othervm -Djdk.nio.enableFastFileTransfer TransferToChannel
  */
 
 import java.nio.channels.FileChannel;