Merge
This commit is contained in:
commit
d9d916addb
51
jdk/make/lib/Lib-jdk.net.gmk
Normal file
51
jdk/make/lib/Lib-jdk.net.gmk
Normal file
@ -0,0 +1,51 @@
|
||||
#
|
||||
# Copyright (c) 2016, 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. Oracle designates this
|
||||
# particular file as subject to the "Classpath" exception as provided
|
||||
# by Oracle in the LICENSE file that accompanied this code.
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
|
||||
include LibCommon.gmk
|
||||
|
||||
################################################################################
|
||||
|
||||
ifeq ($(OPENJDK_TARGET_OS), solaris)
|
||||
|
||||
$(eval $(call SetupNativeCompilation, BUILD_LIBEXTNET, \
|
||||
LIBRARY := extnet, \
|
||||
OUTPUT_DIR := $(INSTALL_LIBRARIES_HERE), \
|
||||
SRC := $(JDK_TOPDIR)/src/jdk.net/solaris/native/libextnet, \
|
||||
OPTIMIZATION := LOW, \
|
||||
CFLAGS := $(CFLAGS_JDKLIB) -I$(SUPPORT_OUTPUTDIR)/headers/jdk.net, \
|
||||
MAPFILE := $(JDK_TOPDIR)/make/mapfiles/libextnet/mapfile-vers, \
|
||||
LDFLAGS := $(LDFLAGS_JDKLIB) \
|
||||
$(call SET_SHARED_LIBRARY_ORIGIN), \
|
||||
LIBS := -lsocket -lc -ljava, \
|
||||
OBJECT_DIR := $(SUPPORT_OUTPUTDIR)/native/$(MODULE)/libextnet, \
|
||||
))
|
||||
|
||||
$(BUILD_LIBEXTNET): $(call FindLib, java.base, java)
|
||||
|
||||
TARGETS += $(BUILD_LIBEXTNET)
|
||||
endif
|
||||
|
||||
|
||||
################################################################################
|
34
jdk/make/mapfiles/libextnet/mapfile-vers
Normal file
34
jdk/make/mapfiles/libextnet/mapfile-vers
Normal file
@ -0,0 +1,34 @@
|
||||
#
|
||||
# Copyright (c) 2016, 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. Oracle designates this
|
||||
# particular file as subject to the "Classpath" exception as provided
|
||||
# by Oracle in the LICENSE file that accompanied this code.
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
|
||||
SUNWprivate_1.1 {
|
||||
global:
|
||||
Java_jdk_net_SolarisSocketOptions_init;
|
||||
Java_jdk_net_SolarisSocketOptions_setFlowOption;
|
||||
Java_jdk_net_SolarisSocketOptions_getFlowOption;
|
||||
Java_jdk_net_SolarisSocketOptions_flowSupported;
|
||||
local:
|
||||
*;
|
||||
};
|
@ -98,10 +98,6 @@ SUNWprivate_1.1 {
|
||||
Java_sun_net_sdp_SdpSupport_create0;
|
||||
Java_sun_net_spi_DefaultProxySelector_init;
|
||||
Java_sun_net_spi_DefaultProxySelector_getSystemProxy;
|
||||
Java_sun_net_ExtendedOptionsImpl_init;
|
||||
Java_sun_net_ExtendedOptionsImpl_setFlowOption;
|
||||
Java_sun_net_ExtendedOptionsImpl_getFlowOption;
|
||||
Java_sun_net_ExtendedOptionsImpl_flowSupported;
|
||||
NET_AllocSockaddr;
|
||||
NET_SockaddrToInetAddress;
|
||||
NET_SockaddrEqualsInetAddress;
|
||||
|
@ -3,6 +3,6 @@ build.xml.script.CRC32=f902e8b8
|
||||
build.xml.stylesheet.CRC32=8064a381@1.75.2.48
|
||||
# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
|
||||
# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
|
||||
nbproject/build-impl.xml.data.CRC32=55414227
|
||||
nbproject/build-impl.xml.data.CRC32=16caf60f
|
||||
nbproject/build-impl.xml.script.CRC32=c12f9d04
|
||||
nbproject/build-impl.xml.stylesheet.CRC32=05530350@1.79.1.48
|
||||
|
@ -76,4 +76,4 @@ source.encoding=UTF-8
|
||||
src.src.dir=..\\..\\..\\test\\sanity\\client\\SwingSet\\src
|
||||
src.src2.dir=..\\..\\..\\test\\sanity\\client\\lib\\SwingSet3\\src
|
||||
src.src3.dir=..\\..\\..\\test\\sanity\\client\\lib\\jemmy\\src
|
||||
src.src4.dir=..\\..\\..\\test\\sanity\\client\\lib\\Jemmy2Ext\\src
|
||||
src.src4.dir=..\\..\\..\\test\\sanity\\client\\lib\\Extensions\\src
|
||||
|
@ -6,7 +6,7 @@
|
||||
<name>SanityTests</name>
|
||||
<source-roots>
|
||||
<root id="src.src3.dir" name="lib\jemmy\src"/>
|
||||
<root id="src.src4.dir" name="lib\Jemmy2Ext\src"/>
|
||||
<root id="src.src4.dir" name="lib\Extensions\src"/>
|
||||
<root id="src.src2.dir" name="lib\SwingSet3\src"/>
|
||||
<root id="src.src.dir" name="SwingSet\src"/>
|
||||
</source-roots>
|
||||
|
@ -52,7 +52,7 @@ public class GenModuleInfoSource {
|
||||
"Usage: GenModuleInfoSource [option] -o <output file> <module-info-java>\n" +
|
||||
"Options are:\n" +
|
||||
" -exports <package-name>\n" +
|
||||
" -exports <package-name>/<module-name>\n" +
|
||||
" -exports <package-name>[/<module-name>]\n" +
|
||||
" -uses <service>\n" +
|
||||
" -provides <service>/<provider-impl-classname>\n";
|
||||
|
||||
|
@ -1155,8 +1155,9 @@ public final class System {
|
||||
* @param level the log message level.
|
||||
* @param msg the string message (or a key in the message catalog, if
|
||||
* this logger is a {@link
|
||||
* LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class)
|
||||
* localized logger}); can be {@code null}.
|
||||
* LoggerFinder#getLocalizedLogger(java.lang.String,
|
||||
* java.util.ResourceBundle, java.lang.reflect.Module) localized logger});
|
||||
* can be {@code null}.
|
||||
*
|
||||
* @throws NullPointerException if {@code level} is {@code null}.
|
||||
*/
|
||||
@ -1222,8 +1223,9 @@ public final class System {
|
||||
* @param level the log message level.
|
||||
* @param msg the string message (or a key in the message catalog, if
|
||||
* this logger is a {@link
|
||||
* LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class)
|
||||
* localized logger}); can be {@code null}.
|
||||
* LoggerFinder#getLocalizedLogger(java.lang.String,
|
||||
* java.util.ResourceBundle, java.lang.reflect.Module) localized logger});
|
||||
* can be {@code null}.
|
||||
* @param thrown a {@code Throwable} associated with the log message;
|
||||
* can be {@code null}.
|
||||
*
|
||||
@ -1270,8 +1272,9 @@ public final class System {
|
||||
* @param format the string message format in {@link
|
||||
* java.text.MessageFormat} format, (or a key in the message
|
||||
* catalog, if this logger is a {@link
|
||||
* LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class)
|
||||
* localized logger}); can be {@code null}.
|
||||
* LoggerFinder#getLocalizedLogger(java.lang.String,
|
||||
* java.util.ResourceBundle, java.lang.reflect.Module) localized logger});
|
||||
* can be {@code null}.
|
||||
* @param params an optional list of parameters to the message (may be
|
||||
* none).
|
||||
*
|
||||
@ -1453,30 +1456,30 @@ public final class System {
|
||||
|
||||
/**
|
||||
* Returns an instance of {@link Logger Logger}
|
||||
* for the given {@code caller}.
|
||||
* for the given {@code module}.
|
||||
*
|
||||
* @param name the name of the logger.
|
||||
* @param caller the class for which the logger is being requested.
|
||||
* @param module the module for which the logger is being requested.
|
||||
*
|
||||
* @return a {@link Logger logger} suitable for the given caller's
|
||||
* use.
|
||||
* @return a {@link Logger logger} suitable for use within the given
|
||||
* module.
|
||||
* @throws NullPointerException if {@code name} is {@code null} or
|
||||
* {@code caller} is {@code null}.
|
||||
* {@code module} is {@code null}.
|
||||
* @throws SecurityException if a security manager is present and its
|
||||
* {@code checkPermission} method doesn't allow the
|
||||
* {@code RuntimePermission("loggerFinder")}.
|
||||
*/
|
||||
public abstract Logger getLogger(String name, /* Module */ Class<?> caller);
|
||||
public abstract Logger getLogger(String name, Module module);
|
||||
|
||||
/**
|
||||
* Returns a localizable instance of {@link Logger Logger}
|
||||
* for the given {@code caller}.
|
||||
* for the given {@code module}.
|
||||
* The returned logger will use the provided resource bundle for
|
||||
* message localization.
|
||||
*
|
||||
* @implSpec By default, this method calls {@link
|
||||
* #getLogger(java.lang.String, java.lang.Class)
|
||||
* this.getLogger(name, caller)} to obtain a logger, then wraps that
|
||||
* #getLogger(java.lang.String, java.lang.reflect.Module)
|
||||
* this.getLogger(name, module)} to obtain a logger, then wraps that
|
||||
* logger in a {@link Logger} instance where all methods that do not
|
||||
* take a {@link ResourceBundle} as parameter are redirected to one
|
||||
* which does - passing the given {@code bundle} for
|
||||
@ -1499,19 +1502,19 @@ public final class System {
|
||||
*
|
||||
* @param name the name of the logger.
|
||||
* @param bundle a resource bundle; can be {@code null}.
|
||||
* @param caller the class for which the logger is being requested.
|
||||
* @param module the module for which the logger is being requested.
|
||||
* @return an instance of {@link Logger Logger} which will use the
|
||||
* provided resource bundle for message localization.
|
||||
*
|
||||
* @throws NullPointerException if {@code name} is {@code null} or
|
||||
* {@code caller} is {@code null}.
|
||||
* {@code module} is {@code null}.
|
||||
* @throws SecurityException if a security manager is present and its
|
||||
* {@code checkPermission} method doesn't allow the
|
||||
* {@code RuntimePermission("loggerFinder")}.
|
||||
*/
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle,
|
||||
/* Module */ Class<?> caller) {
|
||||
return new LocalizedLoggerWrapper<>(getLogger(name, caller), bundle);
|
||||
Module module) {
|
||||
return new LocalizedLoggerWrapper<>(getLogger(name, module), bundle);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1558,12 +1561,13 @@ public final class System {
|
||||
*
|
||||
* @implSpec
|
||||
* Instances returned by this method route messages to loggers
|
||||
* obtained by calling {@link LoggerFinder#getLogger(java.lang.String, java.lang.Class)
|
||||
* LoggerFinder.getLogger(name, caller)}.
|
||||
* obtained by calling {@link LoggerFinder#getLogger(java.lang.String,
|
||||
* java.lang.reflect.Module) LoggerFinder.getLogger(name, module)}, where
|
||||
* {@code module} is the caller's module.
|
||||
*
|
||||
* @apiNote
|
||||
* This method may defer calling the {@link
|
||||
* LoggerFinder#getLogger(java.lang.String, java.lang.Class)
|
||||
* LoggerFinder#getLogger(java.lang.String, java.lang.reflect.Module)
|
||||
* LoggerFinder.getLogger} method to create an actual logger supplied by
|
||||
* the logging backend, for instance, to allow loggers to be obtained during
|
||||
* the system initialization time.
|
||||
@ -1579,7 +1583,7 @@ public final class System {
|
||||
public static Logger getLogger(String name) {
|
||||
Objects.requireNonNull(name);
|
||||
final Class<?> caller = Reflection.getCallerClass();
|
||||
return LazyLoggers.getLogger(name, caller);
|
||||
return LazyLoggers.getLogger(name, caller.getModule());
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1591,8 +1595,9 @@ public final class System {
|
||||
* @implSpec
|
||||
* The returned logger will perform message localization as specified
|
||||
* by {@link LoggerFinder#getLocalizedLogger(java.lang.String,
|
||||
* java.util.ResourceBundle, java.lang.Class)
|
||||
* LoggerFinder.getLocalizedLogger(name, bundle, caller}.
|
||||
* java.util.ResourceBundle, java.lang.reflect.Module)
|
||||
* LoggerFinder.getLocalizedLogger(name, bundle, module}, where
|
||||
* {@code module} is the caller's module.
|
||||
*
|
||||
* @apiNote
|
||||
* This method is intended to be used after the system is fully initialized.
|
||||
@ -1624,12 +1629,14 @@ public final class System {
|
||||
// Bootstrap sensitive classes in the JDK do not use resource bundles
|
||||
// when logging. This could be revisited later, if it needs to.
|
||||
if (sm != null) {
|
||||
return AccessController.doPrivileged((PrivilegedAction<Logger>)
|
||||
() -> LoggerFinder.accessProvider().getLocalizedLogger(name, rb, caller),
|
||||
null,
|
||||
LoggerFinder.LOGGERFINDER_PERMISSION);
|
||||
final PrivilegedAction<Logger> pa =
|
||||
() -> LoggerFinder.accessProvider()
|
||||
.getLocalizedLogger(name, rb, caller.getModule());
|
||||
return AccessController.doPrivileged(pa, null,
|
||||
LoggerFinder.LOGGERFINDER_PERMISSION);
|
||||
}
|
||||
return LoggerFinder.accessProvider().getLocalizedLogger(name, rb, caller);
|
||||
return LoggerFinder.accessProvider()
|
||||
.getLocalizedLogger(name, rb, caller.getModule());
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -25,6 +25,7 @@
|
||||
|
||||
package java.lang.invoke;
|
||||
|
||||
import java.lang.reflect.Array;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.util.Arrays;
|
||||
@ -1892,7 +1893,8 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
|
||||
MH_tryFinallyExec = 12,
|
||||
MH_tryFinallyVoidExec = 13,
|
||||
MH_decrementCounter = 14,
|
||||
MH_LIMIT = 15;
|
||||
MH_Array_newInstance = 15,
|
||||
MH_LIMIT = 16;
|
||||
|
||||
static MethodHandle getConstantHandle(int idx) {
|
||||
MethodHandle handle = HANDLES[idx];
|
||||
@ -1965,6 +1967,9 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
|
||||
case MH_decrementCounter:
|
||||
return IMPL_LOOKUP.findStatic(MethodHandleImpl.class, "decrementCounter",
|
||||
MethodType.methodType(int.class, int.class));
|
||||
case MH_Array_newInstance:
|
||||
return IMPL_LOOKUP.findStatic(Array.class, "newInstance",
|
||||
MethodType.methodType(Object.class, Class.class, int.class));
|
||||
}
|
||||
} catch (ReflectiveOperationException ex) {
|
||||
throw newInternalError(ex);
|
||||
|
@ -25,34 +25,38 @@
|
||||
|
||||
package java.lang.invoke;
|
||||
|
||||
import java.lang.reflect.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.BitSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Arrays;
|
||||
import java.util.Objects;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
|
||||
import jdk.internal.org.objectweb.asm.ClassWriter;
|
||||
import jdk.internal.org.objectweb.asm.Opcodes;
|
||||
import jdk.internal.reflect.CallerSensitive;
|
||||
import jdk.internal.reflect.Reflection;
|
||||
import sun.invoke.util.ValueConversions;
|
||||
import sun.invoke.util.VerifyAccess;
|
||||
import sun.invoke.util.Wrapper;
|
||||
import jdk.internal.reflect.CallerSensitive;
|
||||
import jdk.internal.reflect.Reflection;
|
||||
import sun.reflect.misc.ReflectUtil;
|
||||
import sun.security.util.SecurityConstants;
|
||||
import java.lang.invoke.LambdaForm.BasicType;
|
||||
|
||||
import static java.lang.invoke.MethodHandleImpl.Intrinsic;
|
||||
import static java.lang.invoke.MethodHandleNatives.Constants.*;
|
||||
import java.lang.invoke.LambdaForm.BasicType;
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Member;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.lang.reflect.ReflectPermission;
|
||||
import java.nio.ByteOrder;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.BitSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import jdk.internal.org.objectweb.asm.ClassWriter;
|
||||
import jdk.internal.org.objectweb.asm.Opcodes;
|
||||
|
||||
import static java.lang.invoke.MethodHandleImpl.Intrinsic;
|
||||
import static java.lang.invoke.MethodHandleNatives.Constants.*;
|
||||
import static java.lang.invoke.MethodHandleStatics.newIllegalArgumentException;
|
||||
import static java.lang.invoke.MethodType.methodType;
|
||||
|
||||
@ -741,10 +745,13 @@ public class MethodHandles {
|
||||
if (name.startsWith("java.lang.invoke."))
|
||||
throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);
|
||||
|
||||
// For caller-sensitive MethodHandles.lookup()
|
||||
// disallow lookup more restricted packages
|
||||
// For caller-sensitive MethodHandles.lookup() disallow lookup from
|
||||
// restricted packages. This a fragile and blunt approach.
|
||||
// TODO replace with a more formal and less fragile mechanism
|
||||
// that does not bluntly restrict classes under packages within
|
||||
// java.base from looking up MethodHandles or VarHandles.
|
||||
if (allowedModes == ALL_MODES && lookupClass.getClassLoader() == null) {
|
||||
if (name.startsWith("java.") ||
|
||||
if ((name.startsWith("java.") && !name.startsWith("java.util.concurrent.")) ||
|
||||
(name.startsWith("sun.") && !name.startsWith("sun.invoke."))) {
|
||||
throw newIllegalArgumentException("illegal lookupClass: " + lookupClass);
|
||||
}
|
||||
@ -1003,6 +1010,9 @@ assertEquals("[x, y, z]", pb.command().toString());
|
||||
* @throws NullPointerException if any argument is null
|
||||
*/
|
||||
public MethodHandle findConstructor(Class<?> refc, MethodType type) throws NoSuchMethodException, IllegalAccessException {
|
||||
if (refc.isArray()) {
|
||||
throw new NoSuchMethodException("no constructor for array class: " + refc.getName());
|
||||
}
|
||||
String name = "<init>";
|
||||
MemberName ctor = resolveOrFail(REF_newInvokeSpecial, refc, name, type);
|
||||
return getDirectConstructor(refc, ctor);
|
||||
@ -2213,6 +2223,27 @@ return mh1;
|
||||
static final Lookup PUBLIC_LOOKUP = new Lookup(PUBLIC_LOOKUP_CLASS, Lookup.PUBLIC);
|
||||
}
|
||||
|
||||
/**
|
||||
* Produces a method handle constructing arrays of a desired type.
|
||||
* The return type of the method handle will be the array type.
|
||||
* The type of its sole argument will be {@code int}, which specifies the size of the array.
|
||||
* @param arrayClass an array type
|
||||
* @return a method handle which can create arrays of the given type
|
||||
* @throws NullPointerException if the argument is {@code null}
|
||||
* @throws IllegalArgumentException if {@code arrayClass} is not an array type
|
||||
* @see java.lang.reflect.Array#newInstance(Class, int)
|
||||
* @since 9
|
||||
*/
|
||||
public static
|
||||
MethodHandle arrayConstructor(Class<?> arrayClass) throws IllegalArgumentException {
|
||||
if (!arrayClass.isArray()) {
|
||||
throw newIllegalArgumentException("not an array class: " + arrayClass.getName());
|
||||
}
|
||||
MethodHandle ani = MethodHandleImpl.getConstantHandle(MethodHandleImpl.MH_Array_newInstance).
|
||||
bindTo(arrayClass.getComponentType());
|
||||
return ani.asType(ani.type().changeReturnType(arrayClass));
|
||||
}
|
||||
|
||||
/**
|
||||
* Produces a method handle giving read access to elements of an array.
|
||||
* The type of the method handle will have a return type of the array's
|
||||
@ -2337,13 +2368,12 @@ return mh1;
|
||||
*
|
||||
* @param viewArrayClass the view array class, with a component type of
|
||||
* type {@code T}
|
||||
* @param bigEndian true if the endianness of the view array elements, as
|
||||
* stored in the underlying {@code byte} array, is big endian, otherwise
|
||||
* little endian
|
||||
* @param byteOrder the endianness of the view array elements, as
|
||||
* stored in the underlying {@code byte} array
|
||||
* @return a VarHandle giving access to elements of a {@code byte[]} array
|
||||
* viewed as if elements corresponding to the components type of the view
|
||||
* array class
|
||||
* @throws NullPointerException if viewArrayClass is null
|
||||
* @throws NullPointerException if viewArrayClass or byteOrder is null
|
||||
* @throws IllegalArgumentException if viewArrayClass is not an array type
|
||||
* @throws UnsupportedOperationException if the component type of
|
||||
* viewArrayClass is not supported as a variable type
|
||||
@ -2351,8 +2381,10 @@ return mh1;
|
||||
*/
|
||||
public static
|
||||
VarHandle byteArrayViewVarHandle(Class<?> viewArrayClass,
|
||||
boolean bigEndian) throws IllegalArgumentException {
|
||||
return VarHandles.byteArrayViewHandle(viewArrayClass, bigEndian);
|
||||
ByteOrder byteOrder) throws IllegalArgumentException {
|
||||
Objects.requireNonNull(byteOrder);
|
||||
return VarHandles.byteArrayViewHandle(viewArrayClass,
|
||||
byteOrder == ByteOrder.BIG_ENDIAN);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -2422,14 +2454,13 @@ return mh1;
|
||||
*
|
||||
* @param viewArrayClass the view array class, with a component type of
|
||||
* type {@code T}
|
||||
* @param bigEndian true if the endianness of the view array elements, as
|
||||
* stored in the underlying {@code ByteBuffer}, is big endian, otherwise
|
||||
* little endian (Note this overrides the endianness of a
|
||||
* {@code ByteBuffer})
|
||||
* @param byteOrder the endianness of the view array elements, as
|
||||
* stored in the underlying {@code ByteBuffer} (Note this overrides the
|
||||
* endianness of a {@code ByteBuffer})
|
||||
* @return a VarHandle giving access to elements of a {@code ByteBuffer}
|
||||
* viewed as if elements corresponding to the components type of the view
|
||||
* array class
|
||||
* @throws NullPointerException if viewArrayClass is null
|
||||
* @throws NullPointerException if viewArrayClass or byteOrder is null
|
||||
* @throws IllegalArgumentException if viewArrayClass is not an array type
|
||||
* @throws UnsupportedOperationException if the component type of
|
||||
* viewArrayClass is not supported as a variable type
|
||||
@ -2437,8 +2468,10 @@ return mh1;
|
||||
*/
|
||||
public static
|
||||
VarHandle byteBufferViewVarHandle(Class<?> viewArrayClass,
|
||||
boolean bigEndian) throws IllegalArgumentException {
|
||||
return VarHandles.makeByteBufferViewHandle(viewArrayClass, bigEndian);
|
||||
ByteOrder byteOrder) throws IllegalArgumentException {
|
||||
Objects.requireNonNull(byteOrder);
|
||||
return VarHandles.makeByteBufferViewHandle(viewArrayClass,
|
||||
byteOrder == ByteOrder.BIG_ENDIAN);
|
||||
}
|
||||
|
||||
|
||||
|
@ -33,6 +33,9 @@ import java.util.function.Function;
|
||||
import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.ref.ReferenceQueue;
|
||||
import java.lang.reflect.Module;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.util.Collection;
|
||||
import java.util.ResourceBundle;
|
||||
|
||||
@ -129,41 +132,49 @@ public class DefaultLoggerFinder extends LoggerFinder {
|
||||
return w;
|
||||
}
|
||||
|
||||
|
||||
final static SharedLoggers system = new SharedLoggers();
|
||||
final static SharedLoggers application = new SharedLoggers();
|
||||
}
|
||||
|
||||
public static boolean isSystem(Module m) {
|
||||
ClassLoader cl = AccessController.doPrivileged(new PrivilegedAction<>() {
|
||||
@Override
|
||||
public ClassLoader run() {
|
||||
return m.getClassLoader();
|
||||
}
|
||||
});
|
||||
return cl == null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public final Logger getLogger(String name, /* Module */ Class<?> caller) {
|
||||
public final Logger getLogger(String name, Module module) {
|
||||
checkPermission();
|
||||
return demandLoggerFor(name, caller);
|
||||
return demandLoggerFor(name, module);
|
||||
}
|
||||
|
||||
@Override
|
||||
public final Logger getLocalizedLogger(String name, ResourceBundle bundle,
|
||||
/* Module */ Class<?> caller) {
|
||||
return super.getLocalizedLogger(name, bundle, caller);
|
||||
Module module) {
|
||||
return super.getLocalizedLogger(name, bundle, module);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Returns a {@link Logger logger} suitable for the caller usage.
|
||||
* Returns a {@link Logger logger} suitable for use within the
|
||||
* given {@code module}.
|
||||
*
|
||||
* @implSpec The default implementation for this method is to return a
|
||||
* simple logger that will print all messages of INFO level and above
|
||||
* to the console. That simple logger is not configurable.
|
||||
*
|
||||
* @param name The name of the logger.
|
||||
* @param caller The class on behalf of which the logger is created.
|
||||
* @param module The module on behalf of which the logger is created.
|
||||
* @return A {@link Logger logger} suitable for the application usage.
|
||||
* @throws SecurityException if the calling code does not have the
|
||||
* {@code RuntimePermission("loggerFinder")}.
|
||||
*/
|
||||
protected Logger demandLoggerFor(String name, /* Module */ Class<?> caller) {
|
||||
protected Logger demandLoggerFor(String name, Module module) {
|
||||
checkPermission();
|
||||
if (caller.getClassLoader() == null) {
|
||||
if (isSystem(module)) {
|
||||
return SharedLoggers.system.get(SimpleConsoleLogger::makeSimpleLogger, name);
|
||||
} else {
|
||||
return SharedLoggers.application.get(SimpleConsoleLogger::makeSimpleLogger, name);
|
||||
|
@ -31,6 +31,7 @@ import java.util.function.BiFunction;
|
||||
import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.ref.WeakReference;
|
||||
import java.lang.reflect.Module;
|
||||
import java.util.Objects;
|
||||
import jdk.internal.misc.VM;
|
||||
import sun.util.logging.PlatformLogger;
|
||||
@ -59,15 +60,15 @@ public final class LazyLoggers {
|
||||
* A factory method to create an SPI logger.
|
||||
* Usually, this will be something like LazyLoggers::getSystemLogger.
|
||||
*/
|
||||
final BiFunction<String, Class<?>, L> loggerSupplier;
|
||||
final BiFunction<String, Module, L> loggerSupplier;
|
||||
|
||||
|
||||
public LazyLoggerFactories(BiFunction<String, Class<?>, L> loggerSupplier) {
|
||||
public LazyLoggerFactories(BiFunction<String, Module, L> loggerSupplier) {
|
||||
this(Objects.requireNonNull(loggerSupplier),
|
||||
(Void)null);
|
||||
}
|
||||
|
||||
private LazyLoggerFactories(BiFunction<String, Class<?>, L> loggerSupplier,
|
||||
private LazyLoggerFactories(BiFunction<String, Module, L> loggerSupplier,
|
||||
Void unused) {
|
||||
this.loggerSupplier = loggerSupplier;
|
||||
}
|
||||
@ -107,8 +108,8 @@ public final class LazyLoggers {
|
||||
// The factories that will be used to create the logger lazyly
|
||||
final LazyLoggerFactories<? extends Logger> factories;
|
||||
|
||||
// We need to pass the actual caller when creating the logger.
|
||||
private final WeakReference<Class<?>> callerRef;
|
||||
// We need to pass the actual caller module when creating the logger.
|
||||
private final WeakReference<Module> moduleRef;
|
||||
|
||||
// The name of the logger that will be created lazyly
|
||||
final String name;
|
||||
@ -121,17 +122,17 @@ public final class LazyLoggers {
|
||||
|
||||
private LazyLoggerAccessor(String name,
|
||||
LazyLoggerFactories<? extends Logger> factories,
|
||||
Class<?> caller) {
|
||||
Module module) {
|
||||
this(Objects.requireNonNull(name), Objects.requireNonNull(factories),
|
||||
Objects.requireNonNull(caller), null);
|
||||
Objects.requireNonNull(module), null);
|
||||
}
|
||||
|
||||
private LazyLoggerAccessor(String name,
|
||||
LazyLoggerFactories<? extends Logger> factories,
|
||||
Class<?> caller, Void unused) {
|
||||
Module module, Void unused) {
|
||||
this.name = name;
|
||||
this.factories = factories;
|
||||
this.callerRef = new WeakReference<Class<?>>(caller);
|
||||
this.moduleRef = new WeakReference<>(module);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -270,12 +271,12 @@ public final class LazyLoggers {
|
||||
|
||||
// Creates the wrapped logger by invoking the SPI.
|
||||
Logger createLogger() {
|
||||
final Class<?> caller = callerRef.get();
|
||||
if (caller == null) {
|
||||
throw new IllegalStateException("The class for which this logger"
|
||||
final Module module = moduleRef.get();
|
||||
if (module == null) {
|
||||
throw new IllegalStateException("The module for which this logger"
|
||||
+ " was created has been garbage collected");
|
||||
}
|
||||
return this.factories.loggerSupplier.apply(name, caller);
|
||||
return this.factories.loggerSupplier.apply(name, module);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -289,8 +290,8 @@ public final class LazyLoggers {
|
||||
* @return A new LazyLoggerAccessor.
|
||||
*/
|
||||
public static LazyLoggerAccessor makeAccessor(String name,
|
||||
LazyLoggerFactories<? extends Logger> factories, Class<?> caller) {
|
||||
return new LazyLoggerAccessor(name, factories, caller);
|
||||
LazyLoggerFactories<? extends Logger> factories, Module module) {
|
||||
return new LazyLoggerAccessor(name, factories, module);
|
||||
}
|
||||
|
||||
}
|
||||
@ -346,11 +347,11 @@ public final class LazyLoggers {
|
||||
|
||||
// Avoid using lambda here as lazy loggers could be created early
|
||||
// in the bootstrap sequence...
|
||||
private static final BiFunction<String, Class<?>, Logger> loggerSupplier =
|
||||
private static final BiFunction<String, Module, Logger> loggerSupplier =
|
||||
new BiFunction<>() {
|
||||
@Override
|
||||
public Logger apply(String name, Class<?> caller) {
|
||||
return LazyLoggers.getLoggerFromFinder(name, caller);
|
||||
public Logger apply(String name, Module module) {
|
||||
return LazyLoggers.getLoggerFromFinder(name, module);
|
||||
}
|
||||
};
|
||||
|
||||
@ -367,8 +368,8 @@ public final class LazyLoggers {
|
||||
// logger provider until the VM has finished booting.
|
||||
//
|
||||
private static final class JdkLazyLogger extends LazyLoggerWrapper {
|
||||
JdkLazyLogger(String name, Class<?> caller) {
|
||||
this(LazyLoggerAccessor.makeAccessor(name, factories, caller),
|
||||
JdkLazyLogger(String name, Module module) {
|
||||
this(LazyLoggerAccessor.makeAccessor(name, factories, module),
|
||||
(Void)null);
|
||||
}
|
||||
private JdkLazyLogger(LazyLoggerAccessor holder, Void unused) {
|
||||
@ -380,16 +381,16 @@ public final class LazyLoggers {
|
||||
* Gets a logger from the LoggerFinder. Creates the actual concrete
|
||||
* logger.
|
||||
* @param name name of the logger
|
||||
* @param caller class on behalf of which the logger is created
|
||||
* @param module module on behalf of which the logger is created
|
||||
* @return The logger returned by the LoggerFinder.
|
||||
*/
|
||||
static Logger getLoggerFromFinder(String name, Class<?> caller) {
|
||||
static Logger getLoggerFromFinder(String name, Module module) {
|
||||
final SecurityManager sm = System.getSecurityManager();
|
||||
if (sm == null) {
|
||||
return accessLoggerFinder().getLogger(name, caller);
|
||||
return accessLoggerFinder().getLogger(name, module);
|
||||
} else {
|
||||
return AccessController.doPrivileged((PrivilegedAction<Logger>)
|
||||
() -> {return accessLoggerFinder().getLogger(name, caller);},
|
||||
() -> {return accessLoggerFinder().getLogger(name, module);},
|
||||
null, LOGGERFINDER_PERMISSION);
|
||||
}
|
||||
}
|
||||
@ -398,22 +399,22 @@ public final class LazyLoggers {
|
||||
* Returns a (possibly lazy) Logger for the caller.
|
||||
*
|
||||
* @param name the logger name
|
||||
* @param caller The class on behalf of which the logger is created.
|
||||
* If the caller is not loaded from the Boot ClassLoader,
|
||||
* @param module The module on behalf of which the logger is created.
|
||||
* If the module is not loaded from the Boot ClassLoader,
|
||||
* the LoggerFinder is accessed and the logger returned
|
||||
* by {@link LoggerFinder#getLogger(java.lang.String, java.lang.Class)}
|
||||
* by {@link LoggerFinder#getLogger(java.lang.String, java.lang.reflect.Module)}
|
||||
* is returned to the caller directly.
|
||||
* Otherwise, the logger returned by
|
||||
* {@link #getLazyLogger(java.lang.String, java.lang.Class)}
|
||||
* {@link #getLazyLogger(java.lang.String, java.lang.reflect.Module)}
|
||||
* is returned to the caller.
|
||||
*
|
||||
* @return a (possibly lazy) Logger instance.
|
||||
*/
|
||||
public static final Logger getLogger(String name, Class<?> caller) {
|
||||
if (caller.getClassLoader() == null) {
|
||||
return getLazyLogger(name, caller);
|
||||
public static final Logger getLogger(String name, Module module) {
|
||||
if (DefaultLoggerFinder.isSystem(module)) {
|
||||
return getLazyLogger(name, module);
|
||||
} else {
|
||||
return getLoggerFromFinder(name, caller);
|
||||
return getLoggerFromFinder(name, module);
|
||||
}
|
||||
}
|
||||
|
||||
@ -423,10 +424,10 @@ public final class LazyLoggers {
|
||||
* returned by {@link BootstrapLogger#useLazyLoggers()}.
|
||||
*
|
||||
* @param name the logger name
|
||||
* @param caller the class on behalf of which the logger is created.
|
||||
* @param module the module on behalf of which the logger is created.
|
||||
* @return a (possibly lazy) Logger instance.
|
||||
*/
|
||||
public static final Logger getLazyLogger(String name, Class<?> caller) {
|
||||
public static final Logger getLazyLogger(String name, Module module) {
|
||||
|
||||
// BootstrapLogger has the logic to determine whether a LazyLogger
|
||||
// should be used. Usually, it is worth it only if:
|
||||
@ -438,10 +439,10 @@ public final class LazyLoggers {
|
||||
// configuration, we're not going to delay the creation of loggers...
|
||||
final boolean useLazyLogger = BootstrapLogger.useLazyLoggers();
|
||||
if (useLazyLogger) {
|
||||
return new JdkLazyLogger(name, caller);
|
||||
return new JdkLazyLogger(name, module);
|
||||
} else {
|
||||
// Directly invoke the LoggerFinder.
|
||||
return getLoggerFromFinder(name, caller);
|
||||
return getLoggerFromFinder(name, module);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,61 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package jdk.net;
|
||||
|
||||
import java.net.SocketOption;
|
||||
|
||||
/**
|
||||
* Defines extended socket options, beyond those defined in
|
||||
* {@link java.net.StandardSocketOptions}. These options may be platform
|
||||
* specific.
|
||||
*
|
||||
* @since 1.8
|
||||
*/
|
||||
public final class ExtendedSocketOptions {
|
||||
|
||||
private static class ExtSocketOption<T> implements SocketOption<T> {
|
||||
private final String name;
|
||||
private final Class<T> type;
|
||||
ExtSocketOption(String name, Class<T> type) {
|
||||
this.name = name;
|
||||
this.type = type;
|
||||
}
|
||||
@Override public String name() { return name; }
|
||||
@Override public Class<T> type() { return type; }
|
||||
@Override public String toString() { return name; }
|
||||
}
|
||||
|
||||
private ExtendedSocketOptions() {}
|
||||
|
||||
/**
|
||||
* Service level properties. When a security manager is installed,
|
||||
* setting or getting this option requires a {@link NetworkPermission}
|
||||
* {@code ("setOption.SO_FLOW_SLA")} or {@code "getOption.SO_FLOW_SLA"}
|
||||
* respectively.
|
||||
*/
|
||||
public static final SocketOption<SocketFlow> SO_FLOW_SLA = new
|
||||
ExtSocketOption<SocketFlow>("SO_FLOW_SLA", SocketFlow.class);
|
||||
}
|
@ -83,8 +83,6 @@ module java.base {
|
||||
|
||||
// see JDK-8144062
|
||||
exports jdk;
|
||||
// see JDK-8044773
|
||||
exports jdk.net;
|
||||
|
||||
|
||||
// the service types defined by the APIs in this module
|
||||
@ -168,6 +166,7 @@ module java.base {
|
||||
java.sql,
|
||||
java.xml,
|
||||
jdk.charsets,
|
||||
jdk.net,
|
||||
jdk.scripting.nashorn,
|
||||
jdk.unsupported,
|
||||
jdk.vm.ci;
|
||||
@ -194,6 +193,8 @@ module java.base {
|
||||
jdk.jvmstat;
|
||||
exports sun.net to
|
||||
java.httpclient;
|
||||
exports sun.net.ext to
|
||||
jdk.net;
|
||||
exports sun.net.dns to
|
||||
java.security.jgss,
|
||||
jdk.naming.dns;
|
||||
|
@ -1,92 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package sun.net;
|
||||
|
||||
import java.net.*;
|
||||
import jdk.net.*;
|
||||
import java.io.IOException;
|
||||
import java.io.FileDescriptor;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.security.AccessController;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.Set;
|
||||
import java.util.HashSet;
|
||||
import java.util.HashMap;
|
||||
import java.util.Collections;
|
||||
|
||||
/**
|
||||
* Contains the native implementation for extended socket options
|
||||
* together with some other static utilities
|
||||
*/
|
||||
public class ExtendedOptionsImpl {
|
||||
|
||||
static {
|
||||
AccessController.doPrivileged((PrivilegedAction<Void>)() -> {
|
||||
System.loadLibrary("net");
|
||||
return null;
|
||||
});
|
||||
init();
|
||||
}
|
||||
|
||||
private ExtendedOptionsImpl() {}
|
||||
|
||||
public static void checkSetOptionPermission(SocketOption<?> option) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm == null) {
|
||||
return;
|
||||
}
|
||||
String check = "setOption." + option.name();
|
||||
sm.checkPermission(new NetworkPermission(check));
|
||||
}
|
||||
|
||||
public static void checkGetOptionPermission(SocketOption<?> option) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm == null) {
|
||||
return;
|
||||
}
|
||||
String check = "getOption." + option.name();
|
||||
sm.checkPermission(new NetworkPermission(check));
|
||||
}
|
||||
|
||||
public static void checkValueType(Object value, Class<?> type) {
|
||||
if (!type.isAssignableFrom(value.getClass())) {
|
||||
String s = "Found: " + value.getClass().toString() + " Expected: "
|
||||
+ type.toString();
|
||||
throw new IllegalArgumentException(s);
|
||||
}
|
||||
}
|
||||
|
||||
private static native void init();
|
||||
|
||||
/*
|
||||
* Extension native implementations
|
||||
*
|
||||
* SO_FLOW_SLA
|
||||
*/
|
||||
public static native void setFlowOption(FileDescriptor fd, SocketFlow f);
|
||||
public static native void getFlowOption(FileDescriptor fd, SocketFlow f);
|
||||
public static native boolean flowSupported();
|
||||
}
|
@ -0,0 +1,110 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package sun.net.ext;
|
||||
|
||||
import java.io.FileDescriptor;
|
||||
import java.net.SocketException;
|
||||
import java.net.SocketOption;
|
||||
import java.util.Collections;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* Defines the infrastructure to support extended socket options, beyond those
|
||||
* defined in {@link java.net.StandardSocketOptions}.
|
||||
*
|
||||
* Extended socket options are accessed through the jdk.net API, which is in
|
||||
* the jdk.net module.
|
||||
*/
|
||||
public abstract class ExtendedSocketOptions {
|
||||
|
||||
private final Set<SocketOption<?>> options;
|
||||
|
||||
/** Tells whether or not the option is supported. */
|
||||
public final boolean isOptionSupported(SocketOption<?> option) {
|
||||
return options().contains(option);
|
||||
}
|
||||
|
||||
/** Return the, possibly empty, set of extended socket options available. */
|
||||
public final Set<SocketOption<?>> options() { return options; }
|
||||
|
||||
/** Sets the value of a socket option, for the given socket. */
|
||||
public abstract void setOption(FileDescriptor fd, SocketOption<?> option, Object value)
|
||||
throws SocketException;
|
||||
|
||||
/** Returns the value of a socket option, for the given socket. */
|
||||
public abstract Object getOption(FileDescriptor fd, SocketOption<?> option)
|
||||
throws SocketException;
|
||||
|
||||
protected ExtendedSocketOptions(Set<SocketOption<?>> options) {
|
||||
this.options = options;
|
||||
}
|
||||
|
||||
private static volatile ExtendedSocketOptions instance;
|
||||
|
||||
public static final ExtendedSocketOptions getInstance() { return instance; }
|
||||
|
||||
/** Registers support for extended socket options. Invoked by the jdk.net module. */
|
||||
public static final void register(ExtendedSocketOptions extOptions) {
|
||||
if (instance != null)
|
||||
throw new InternalError("Attempting to reregister extended options");
|
||||
|
||||
instance = extOptions;
|
||||
}
|
||||
|
||||
static {
|
||||
try {
|
||||
// If the class is present, it will be initialized which
|
||||
// triggers registration of the extended socket options.
|
||||
Class<?> c = Class.forName("jdk.net.ExtendedSocketOptions");
|
||||
} catch (ClassNotFoundException e) {
|
||||
// the jdk.net module is not present => no extended socket options
|
||||
instance = new NoExtendedSocketOptions();
|
||||
}
|
||||
}
|
||||
|
||||
static final class NoExtendedSocketOptions extends ExtendedSocketOptions {
|
||||
|
||||
NoExtendedSocketOptions() {
|
||||
super(Collections.<SocketOption<?>>emptySet());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setOption(FileDescriptor fd, SocketOption<?> option, Object value)
|
||||
throws SocketException
|
||||
{
|
||||
throw new UnsupportedOperationException(
|
||||
"no extended options: " + option.name());
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getOption(FileDescriptor fd, SocketOption<?> option)
|
||||
throws SocketException
|
||||
{
|
||||
throw new UnsupportedOperationException(
|
||||
"no extended options: " + option.name());
|
||||
}
|
||||
}
|
||||
}
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2001, 2016, 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.io.IOException;
|
||||
import java.nio.channels.*;
|
||||
import java.nio.channels.spi.*;
|
||||
import java.util.*;
|
||||
import sun.misc.*;
|
||||
|
||||
|
||||
/**
|
||||
|
@ -39,7 +39,7 @@ import java.util.Collections;
|
||||
import java.util.concurrent.*;
|
||||
import java.util.concurrent.locks.*;
|
||||
import sun.net.NetHooks;
|
||||
import sun.net.ExtendedOptionsImpl;
|
||||
import sun.net.ext.ExtendedSocketOptions;
|
||||
|
||||
/**
|
||||
* Base implementation of AsynchronousSocketChannel
|
||||
@ -512,9 +512,9 @@ abstract class AsynchronousSocketChannelImpl
|
||||
set.add(StandardSocketOptions.SO_REUSEPORT);
|
||||
}
|
||||
set.add(StandardSocketOptions.TCP_NODELAY);
|
||||
if (ExtendedOptionsImpl.flowSupported()) {
|
||||
set.add(jdk.net.ExtendedSocketOptions.SO_FLOW_SLA);
|
||||
}
|
||||
ExtendedSocketOptions extendedOptions =
|
||||
ExtendedSocketOptions.getInstance();
|
||||
set.addAll(extendedOptions.options());
|
||||
return Collections.unmodifiableSet(set);
|
||||
}
|
||||
}
|
||||
|
@ -33,7 +33,7 @@ import java.nio.channels.*;
|
||||
import java.nio.channels.spi.*;
|
||||
import java.util.*;
|
||||
import sun.net.ResourceManager;
|
||||
import sun.net.ExtendedOptionsImpl;
|
||||
import sun.net.ext.ExtendedSocketOptions;
|
||||
|
||||
/**
|
||||
* An implementation of DatagramChannels.
|
||||
@ -306,9 +306,9 @@ class DatagramChannelImpl
|
||||
set.add(StandardSocketOptions.IP_MULTICAST_IF);
|
||||
set.add(StandardSocketOptions.IP_MULTICAST_TTL);
|
||||
set.add(StandardSocketOptions.IP_MULTICAST_LOOP);
|
||||
if (ExtendedOptionsImpl.flowSupported()) {
|
||||
set.add(jdk.net.ExtendedSocketOptions.SO_FLOW_SLA);
|
||||
}
|
||||
ExtendedSocketOptions extendedOptions =
|
||||
ExtendedSocketOptions.getInstance();
|
||||
set.addAll(extendedOptions.options());
|
||||
return Collections.unmodifiableSet(set);
|
||||
}
|
||||
}
|
||||
|
@ -27,15 +27,13 @@ package sun.nio.ch;
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import jdk.net.*;
|
||||
import java.nio.channels.*;
|
||||
import java.util.*;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import sun.net.ExtendedOptionsImpl;
|
||||
import sun.net.ext.ExtendedSocketOptions;
|
||||
import sun.security.action.GetPropertyAction;
|
||||
|
||||
|
||||
public class Net {
|
||||
|
||||
private Net() { }
|
||||
@ -281,6 +279,9 @@ public class Net {
|
||||
|
||||
// -- Socket options
|
||||
|
||||
static final ExtendedSocketOptions extendedOptions =
|
||||
ExtendedSocketOptions.getInstance();
|
||||
|
||||
static void setSocketOption(FileDescriptor fd, ProtocolFamily family,
|
||||
SocketOption<?> name, Object value)
|
||||
throws IOException
|
||||
@ -291,12 +292,8 @@ public class Net {
|
||||
// only simple values supported by this method
|
||||
Class<?> type = name.type();
|
||||
|
||||
if (type == SocketFlow.class) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(new NetworkPermission("setOption.SO_FLOW_SLA"));
|
||||
}
|
||||
ExtendedOptionsImpl.setFlowOption(fd, (SocketFlow)value);
|
||||
if (extendedOptions.isOptionSupported(name)) {
|
||||
extendedOptions.setOption(fd, name, value);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -353,14 +350,8 @@ public class Net {
|
||||
{
|
||||
Class<?> type = name.type();
|
||||
|
||||
if (type == SocketFlow.class) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(new NetworkPermission("getOption.SO_FLOW_SLA"));
|
||||
}
|
||||
SocketFlow flow = SocketFlow.create();
|
||||
ExtendedOptionsImpl.getFlowOption(fd, flow);
|
||||
return flow;
|
||||
if (extendedOptions.isOptionSupported(name)) {
|
||||
return extendedOptions.getOption(fd, name);
|
||||
}
|
||||
|
||||
// only simple values supported by this method
|
||||
|
@ -33,8 +33,7 @@ import java.nio.channels.*;
|
||||
import java.nio.channels.spi.*;
|
||||
import java.util.*;
|
||||
import sun.net.NetHooks;
|
||||
import sun.net.ExtendedOptionsImpl;
|
||||
|
||||
import sun.net.ext.ExtendedSocketOptions;
|
||||
|
||||
/**
|
||||
* An implementation of SocketChannels
|
||||
@ -242,9 +241,9 @@ class SocketChannelImpl
|
||||
// additional options required by socket adaptor
|
||||
set.add(StandardSocketOptions.IP_TOS);
|
||||
set.add(ExtendedSocketOption.SO_OOBINLINE);
|
||||
if (ExtendedOptionsImpl.flowSupported()) {
|
||||
set.add(jdk.net.ExtendedSocketOptions.SO_FLOW_SLA);
|
||||
}
|
||||
ExtendedSocketOptions extendedOptions =
|
||||
ExtendedSocketOptions.getInstance();
|
||||
set.addAll(extendedOptions.options());
|
||||
return Collections.unmodifiableSet(set);
|
||||
}
|
||||
}
|
||||
|
@ -286,12 +286,15 @@ public class PlatformLogger {
|
||||
}
|
||||
if (log == null) {
|
||||
log = new PlatformLogger(PlatformLogger.Bridge.convert(
|
||||
// We pass PlatformLogger.class rather than the actual caller
|
||||
// We pass PlatformLogger.class.getModule() (java.base)
|
||||
// rather than the actual module of the caller
|
||||
// because we want PlatformLoggers to be system loggers: we
|
||||
// won't need to resolve any resource bundles anyway.
|
||||
// Note: Many unit tests depend on the fact that
|
||||
// PlatformLogger.getLoggerFromFinder is not caller sensitive.
|
||||
LazyLoggers.getLazyLogger(name, PlatformLogger.class)));
|
||||
// PlatformLogger.getLoggerFromFinder is not caller
|
||||
// sensitive, and this strategy ensure that the tests
|
||||
// still pass.
|
||||
LazyLoggers.getLazyLogger(name, PlatformLogger.class.getModule())));
|
||||
loggers.put(name, new WeakReference<>(log));
|
||||
}
|
||||
return log;
|
||||
|
@ -27,9 +27,7 @@ package java.net;
|
||||
import java.io.IOException;
|
||||
import java.util.Set;
|
||||
import java.util.HashSet;
|
||||
import java.util.Collections;
|
||||
import jdk.net.*;
|
||||
import static sun.net.ExtendedOptionsImpl.*;
|
||||
import sun.net.ext.ExtendedSocketOptions;
|
||||
|
||||
/*
|
||||
* On Unix systems we simply delegate to native methods.
|
||||
@ -43,8 +41,11 @@ class PlainDatagramSocketImpl extends AbstractPlainDatagramSocketImpl
|
||||
init();
|
||||
}
|
||||
|
||||
static final ExtendedSocketOptions extendedOptions =
|
||||
ExtendedSocketOptions.getInstance();
|
||||
|
||||
protected <T> void setOption(SocketOption<T> name, T value) throws IOException {
|
||||
if (!name.equals(ExtendedSocketOptions.SO_FLOW_SLA)) {
|
||||
if (!extendedOptions.isOptionSupported(name)) {
|
||||
if (!name.equals(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
super.setOption(name, value);
|
||||
} else {
|
||||
@ -55,21 +56,16 @@ class PlainDatagramSocketImpl extends AbstractPlainDatagramSocketImpl
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (!flowSupported()) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
if (isClosed()) {
|
||||
throw new SocketException("Socket closed");
|
||||
}
|
||||
checkSetOptionPermission(name);
|
||||
checkValueType(value, SocketFlow.class);
|
||||
setFlowOption(getFileDescriptor(), (SocketFlow)value);
|
||||
extendedOptions.setOption(fd, name, value);
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
protected <T> T getOption(SocketOption<T> name) throws IOException {
|
||||
if (!name.equals(ExtendedSocketOptions.SO_FLOW_SLA)) {
|
||||
if (!extendedOptions.isOptionSupported(name)) {
|
||||
if (!name.equals(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
return super.getOption(name);
|
||||
} else {
|
||||
@ -79,31 +75,23 @@ class PlainDatagramSocketImpl extends AbstractPlainDatagramSocketImpl
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (isClosed()) {
|
||||
throw new SocketException("Socket closed");
|
||||
}
|
||||
return (T) extendedOptions.getOption(fd, name);
|
||||
}
|
||||
if (!flowSupported()) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
if (isClosed()) {
|
||||
throw new SocketException("Socket closed");
|
||||
}
|
||||
checkGetOptionPermission(name);
|
||||
SocketFlow flow = SocketFlow.create();
|
||||
getFlowOption(getFileDescriptor(), flow);
|
||||
return (T)flow;
|
||||
}
|
||||
|
||||
protected Set<SocketOption<?>> supportedOptions() {
|
||||
HashSet<SocketOption<?>> options = new HashSet<>(
|
||||
super.supportedOptions());
|
||||
|
||||
if (flowSupported()) {
|
||||
options.add(ExtendedSocketOptions.SO_FLOW_SLA);
|
||||
}
|
||||
HashSet<SocketOption<?>> options = new HashSet<>(super.supportedOptions());
|
||||
options.addAll(extendedOptions.options());
|
||||
return options;
|
||||
}
|
||||
|
||||
protected void socketSetOption(int opt, Object val) throws SocketException {
|
||||
if (opt == SocketOptions.SO_REUSEPORT && !supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
if (opt == SocketOptions.SO_REUSEPORT &&
|
||||
!supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
try {
|
||||
|
@ -28,10 +28,7 @@ import java.io.IOException;
|
||||
import java.io.FileDescriptor;
|
||||
import java.util.Set;
|
||||
import java.util.HashSet;
|
||||
import java.util.Collections;
|
||||
import jdk.net.*;
|
||||
|
||||
import static sun.net.ExtendedOptionsImpl.*;
|
||||
import sun.net.ext.ExtendedSocketOptions;
|
||||
|
||||
/*
|
||||
* On Unix systems we simply delegate to native methods.
|
||||
@ -57,8 +54,11 @@ class PlainSocketImpl extends AbstractPlainSocketImpl
|
||||
this.fd = fd;
|
||||
}
|
||||
|
||||
static final ExtendedSocketOptions extendedOptions =
|
||||
ExtendedSocketOptions.getInstance();
|
||||
|
||||
protected <T> void setOption(SocketOption<T> name, T value) throws IOException {
|
||||
if (!name.equals(ExtendedSocketOptions.SO_FLOW_SLA)) {
|
||||
if (!extendedOptions.isOptionSupported(name)) {
|
||||
if (!name.equals(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
super.setOption(name, value);
|
||||
} else {
|
||||
@ -69,21 +69,19 @@ class PlainSocketImpl extends AbstractPlainSocketImpl
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (getSocket() == null || !flowSupported()) {
|
||||
if (getSocket() == null) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
if (isClosedOrPending()) {
|
||||
throw new SocketException("Socket closed");
|
||||
}
|
||||
checkSetOptionPermission(name);
|
||||
checkValueType(value, SocketFlow.class);
|
||||
setFlowOption(getFileDescriptor(), (SocketFlow)value);
|
||||
extendedOptions.setOption(fd, name, value);
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
protected <T> T getOption(SocketOption<T> name) throws IOException {
|
||||
if (!name.equals(ExtendedSocketOptions.SO_FLOW_SLA)) {
|
||||
if (!extendedOptions.isOptionSupported(name)) {
|
||||
if (!name.equals(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
return super.getOption(name);
|
||||
} else {
|
||||
@ -93,31 +91,28 @@ class PlainSocketImpl extends AbstractPlainSocketImpl
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (getSocket() == null) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
if (isClosedOrPending()) {
|
||||
throw new SocketException("Socket closed");
|
||||
}
|
||||
return (T) extendedOptions.getOption(fd, name);
|
||||
}
|
||||
if (getSocket() == null || !flowSupported()) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
if (isClosedOrPending()) {
|
||||
throw new SocketException("Socket closed");
|
||||
}
|
||||
checkGetOptionPermission(name);
|
||||
SocketFlow flow = SocketFlow.create();
|
||||
getFlowOption(getFileDescriptor(), flow);
|
||||
return (T)flow;
|
||||
}
|
||||
|
||||
protected Set<SocketOption<?>> supportedOptions() {
|
||||
HashSet<SocketOption<?>> options = new HashSet<>(
|
||||
super.supportedOptions());
|
||||
|
||||
if (getSocket() != null && flowSupported()) {
|
||||
options.add(ExtendedSocketOptions.SO_FLOW_SLA);
|
||||
HashSet<SocketOption<?>> options = new HashSet<>(super.supportedOptions());
|
||||
if (getSocket() != null) {
|
||||
options.addAll(extendedOptions.options());
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
protected void socketSetOption(int opt, boolean b, Object val) throws SocketException {
|
||||
if (opt == SocketOptions.SO_REUSEPORT && !supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
if (opt == SocketOptions.SO_REUSEPORT &&
|
||||
!supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {
|
||||
throw new UnsupportedOperationException("unsupported option");
|
||||
}
|
||||
try {
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2001, 2016, 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.io.IOException;
|
||||
import java.nio.channels.*;
|
||||
import java.nio.channels.spi.*;
|
||||
import java.util.*;
|
||||
import sun.misc.*;
|
||||
|
||||
|
||||
/**
|
||||
|
@ -1,344 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include <jni.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "net_util.h"
|
||||
#include "jdk_net_SocketFlow.h"
|
||||
|
||||
static jclass sf_status_class; /* Status enum type */
|
||||
|
||||
static jfieldID sf_status;
|
||||
static jfieldID sf_priority;
|
||||
static jfieldID sf_bandwidth;
|
||||
|
||||
static jfieldID sf_fd_fdID; /* FileDescriptor.fd */
|
||||
|
||||
/* References to the literal enum values */
|
||||
|
||||
static jobject sfs_NOSTATUS;
|
||||
static jobject sfs_OK;
|
||||
static jobject sfs_NOPERMISSION;
|
||||
static jobject sfs_NOTCONNECTED;
|
||||
static jobject sfs_NOTSUPPORTED;
|
||||
static jobject sfs_ALREADYCREATED;
|
||||
static jobject sfs_INPROGRESS;
|
||||
static jobject sfs_OTHER;
|
||||
|
||||
static jobject getEnumField(JNIEnv *env, char *name);
|
||||
static void setStatus(JNIEnv *env, jobject obj, int errval);
|
||||
|
||||
/* OS specific code is implemented in these three functions */
|
||||
|
||||
static jboolean flowSupported0() ;
|
||||
|
||||
/*
|
||||
* Class: sun_net_ExtendedOptionsImpl
|
||||
* Method: init
|
||||
* Signature: ()V
|
||||
*/
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_init
|
||||
(JNIEnv *env, jclass UNUSED)
|
||||
{
|
||||
static int initialized = 0;
|
||||
jclass c;
|
||||
|
||||
/* Global class references */
|
||||
|
||||
if (initialized) {
|
||||
return;
|
||||
}
|
||||
|
||||
c = (*env)->FindClass(env, "jdk/net/SocketFlow$Status");
|
||||
CHECK_NULL(c);
|
||||
sf_status_class = (*env)->NewGlobalRef(env, c);
|
||||
CHECK_NULL(sf_status_class);
|
||||
|
||||
/* int "fd" field of java.io.FileDescriptor */
|
||||
|
||||
c = (*env)->FindClass(env, "java/io/FileDescriptor");
|
||||
CHECK_NULL(c);
|
||||
sf_fd_fdID = (*env)->GetFieldID(env, c, "fd", "I");
|
||||
CHECK_NULL(sf_fd_fdID);
|
||||
|
||||
|
||||
/* SocketFlow fields */
|
||||
|
||||
c = (*env)->FindClass(env, "jdk/net/SocketFlow");
|
||||
CHECK_NULL(c);
|
||||
|
||||
/* status */
|
||||
|
||||
sf_status = (*env)->GetFieldID(env, c, "status",
|
||||
"Ljdk/net/SocketFlow$Status;");
|
||||
CHECK_NULL(sf_status);
|
||||
|
||||
/* priority */
|
||||
|
||||
sf_priority = (*env)->GetFieldID(env, c, "priority", "I");
|
||||
CHECK_NULL(sf_priority);
|
||||
|
||||
/* bandwidth */
|
||||
|
||||
sf_bandwidth = (*env)->GetFieldID(env, c, "bandwidth", "J");
|
||||
CHECK_NULL(sf_bandwidth);
|
||||
|
||||
/* Initialize the static enum values */
|
||||
|
||||
sfs_NOSTATUS = getEnumField(env, "NO_STATUS");
|
||||
CHECK_NULL(sfs_NOSTATUS);
|
||||
sfs_OK = getEnumField(env, "OK");
|
||||
CHECK_NULL(sfs_OK);
|
||||
sfs_NOPERMISSION = getEnumField(env, "NO_PERMISSION");
|
||||
CHECK_NULL(sfs_NOPERMISSION);
|
||||
sfs_NOTCONNECTED = getEnumField(env, "NOT_CONNECTED");
|
||||
CHECK_NULL(sfs_NOTCONNECTED);
|
||||
sfs_NOTSUPPORTED = getEnumField(env, "NOT_SUPPORTED");
|
||||
CHECK_NULL(sfs_NOTSUPPORTED);
|
||||
sfs_ALREADYCREATED = getEnumField(env, "ALREADY_CREATED");
|
||||
CHECK_NULL(sfs_ALREADYCREATED);
|
||||
sfs_INPROGRESS = getEnumField(env, "IN_PROGRESS");
|
||||
CHECK_NULL(sfs_INPROGRESS);
|
||||
sfs_OTHER = getEnumField(env, "OTHER");
|
||||
CHECK_NULL(sfs_OTHER);
|
||||
initialized = JNI_TRUE;
|
||||
}
|
||||
|
||||
static jobject getEnumField(JNIEnv *env, char *name)
|
||||
{
|
||||
jobject f;
|
||||
jfieldID fID = (*env)->GetStaticFieldID(env, sf_status_class, name,
|
||||
"Ljdk/net/SocketFlow$Status;");
|
||||
CHECK_NULL_RETURN(fID, NULL);
|
||||
|
||||
f = (*env)->GetStaticObjectField(env, sf_status_class, fID);
|
||||
CHECK_NULL_RETURN(f, NULL);
|
||||
f = (*env)->NewGlobalRef(env, f);
|
||||
CHECK_NULL_RETURN(f, NULL);
|
||||
return f;
|
||||
}
|
||||
|
||||
/*
|
||||
* Retrieve the int file-descriptor from a public socket type object.
|
||||
* Gets impl, then the FileDescriptor from the impl, and then the fd
|
||||
* from that.
|
||||
*/
|
||||
static int getFD(JNIEnv *env, jobject fileDesc) {
|
||||
return (*env)->GetIntField(env, fileDesc, sf_fd_fdID);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the status field of a SocketFlow to one of the
|
||||
* canned enum values
|
||||
*/
|
||||
static void setStatus (JNIEnv *env, jobject obj, int errval)
|
||||
{
|
||||
switch (errval) {
|
||||
case 0: /* OK */
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_OK);
|
||||
break;
|
||||
case EPERM:
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_NOPERMISSION);
|
||||
break;
|
||||
case ENOTCONN:
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_NOTCONNECTED);
|
||||
break;
|
||||
case EOPNOTSUPP:
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_NOTSUPPORTED);
|
||||
break;
|
||||
case EALREADY:
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_ALREADYCREATED);
|
||||
break;
|
||||
case EINPROGRESS:
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_INPROGRESS);
|
||||
break;
|
||||
default:
|
||||
(*env)->SetObjectField(env, obj, sf_status, sfs_OTHER);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __solaris__
|
||||
|
||||
/*
|
||||
* Class: sun_net_ExtendedOptionsImpl
|
||||
* Method: setFlowOption
|
||||
* Signature: (Ljava/io/FileDescriptor;Ljdk/net/SocketFlow;)V
|
||||
*/
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_setFlowOption
|
||||
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow)
|
||||
{
|
||||
int fd = getFD(env, fileDesc);
|
||||
|
||||
if (fd < 0) {
|
||||
NET_ERROR(env, JNU_JAVANETPKG "SocketException", "socket closed");
|
||||
return;
|
||||
} else {
|
||||
sock_flow_props_t props;
|
||||
jlong bandwidth;
|
||||
int rv;
|
||||
|
||||
jint priority = (*env)->GetIntField(env, flow, sf_priority);
|
||||
memset(&props, 0, sizeof(props));
|
||||
props.sfp_version = SOCK_FLOW_PROP_VERSION1;
|
||||
|
||||
if (priority != jdk_net_SocketFlow_UNSET) {
|
||||
props.sfp_mask |= SFP_PRIORITY;
|
||||
props.sfp_priority = priority;
|
||||
}
|
||||
bandwidth = (*env)->GetLongField(env, flow, sf_bandwidth);
|
||||
if (bandwidth > -1) {
|
||||
props.sfp_mask |= SFP_MAXBW;
|
||||
props.sfp_maxbw = (uint64_t) bandwidth;
|
||||
}
|
||||
rv = setsockopt(fd, SOL_SOCKET, SO_FLOW_SLA, &props, sizeof(props));
|
||||
if (rv < 0) {
|
||||
if (errno == ENOPROTOOPT) {
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
} else if (errno == EACCES || errno == EPERM) {
|
||||
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
|
||||
"Permission denied");
|
||||
} else {
|
||||
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
|
||||
"set option SO_FLOW_SLA failed");
|
||||
}
|
||||
return;
|
||||
}
|
||||
setStatus(env, flow, props.sfp_status);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Class: sun_net_ExtendedOptionsImpl
|
||||
* Method: getFlowOption
|
||||
* Signature: (Ljava/io/FileDescriptor;Ljdk/net/SocketFlow;)V
|
||||
*/
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_getFlowOption
|
||||
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow)
|
||||
{
|
||||
int fd = getFD(env, fileDesc);
|
||||
|
||||
if (fd < 0) {
|
||||
NET_ERROR(env, JNU_JAVANETPKG "SocketException", "socket closed");
|
||||
return;
|
||||
} else {
|
||||
sock_flow_props_t props;
|
||||
int status;
|
||||
socklen_t sz = sizeof(props);
|
||||
|
||||
int rv = getsockopt(fd, SOL_SOCKET, SO_FLOW_SLA, &props, &sz);
|
||||
if (rv < 0) {
|
||||
if (errno == ENOPROTOOPT) {
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
} else if (errno == EACCES || errno == EPERM) {
|
||||
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
|
||||
"Permission denied");
|
||||
} else {
|
||||
NET_ERROR(env, JNU_JAVANETPKG "SocketException",
|
||||
"set option SO_FLOW_SLA failed");
|
||||
}
|
||||
return;
|
||||
}
|
||||
/* first check status to see if flow exists */
|
||||
status = props.sfp_status;
|
||||
setStatus(env, flow, status);
|
||||
if (status == 0) { /* OK */
|
||||
/* can set the other fields now */
|
||||
if (props.sfp_mask & SFP_PRIORITY) {
|
||||
(*env)->SetIntField(env, flow, sf_priority, props.sfp_priority);
|
||||
}
|
||||
if (props.sfp_mask & SFP_MAXBW) {
|
||||
(*env)->SetLongField(env, flow, sf_bandwidth,
|
||||
(jlong)props.sfp_maxbw);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static jboolean flowsupported;
|
||||
static jboolean flowsupported_set = JNI_FALSE;
|
||||
|
||||
static jboolean flowSupported0()
|
||||
{
|
||||
/* Do a simple dummy call, and try to figure out from that */
|
||||
sock_flow_props_t props;
|
||||
int rv, s;
|
||||
if (flowsupported_set) {
|
||||
return flowsupported;
|
||||
}
|
||||
s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (s < 0) {
|
||||
flowsupported = JNI_FALSE;
|
||||
flowsupported_set = JNI_TRUE;
|
||||
return JNI_FALSE;
|
||||
}
|
||||
memset(&props, 0, sizeof(props));
|
||||
props.sfp_version = SOCK_FLOW_PROP_VERSION1;
|
||||
props.sfp_mask |= SFP_PRIORITY;
|
||||
props.sfp_priority = SFP_PRIO_NORMAL;
|
||||
rv = setsockopt(s, SOL_SOCKET, SO_FLOW_SLA, &props, sizeof(props));
|
||||
if (rv != 0 && errno == ENOPROTOOPT) {
|
||||
rv = JNI_FALSE;
|
||||
} else {
|
||||
rv = JNI_TRUE;
|
||||
}
|
||||
close(s);
|
||||
flowsupported = rv;
|
||||
flowsupported_set = JNI_TRUE;
|
||||
return flowsupported;
|
||||
}
|
||||
|
||||
#else /* __solaris__ */
|
||||
|
||||
/* Non Solaris. Functionality is not supported. So, throw UnsupportedOpExc */
|
||||
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_setFlowOption
|
||||
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow)
|
||||
{
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_getFlowOption
|
||||
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow)
|
||||
{
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
}
|
||||
|
||||
static jboolean flowSupported0() {
|
||||
return JNI_FALSE;
|
||||
}
|
||||
|
||||
#endif /* __solaris__ */
|
||||
|
||||
JNIEXPORT jboolean JNICALL Java_sun_net_ExtendedOptionsImpl_flowSupported
|
||||
(JNIEnv *env, jclass UNUSED)
|
||||
{
|
||||
return flowSupported0();
|
||||
}
|
@ -120,47 +120,6 @@ int getDefaultIPv6Interface(struct in6_addr *target_addr);
|
||||
|
||||
#ifdef __solaris__
|
||||
int net_getParam(char *driver, char *param);
|
||||
|
||||
#ifndef SO_FLOW_SLA
|
||||
#define SO_FLOW_SLA 0x1018
|
||||
|
||||
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
|
||||
#pragma pack(4)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Used with the setsockopt(SO_FLOW_SLA, ...) call to set
|
||||
* per socket service level properties.
|
||||
* When the application uses per-socket API, we will enforce the properties
|
||||
* on both outbound and inbound packets.
|
||||
*
|
||||
* For now, only priority and maxbw are supported in SOCK_FLOW_PROP_VERSION1.
|
||||
*/
|
||||
typedef struct sock_flow_props_s {
|
||||
int sfp_version;
|
||||
uint32_t sfp_mask;
|
||||
int sfp_priority; /* flow priority */
|
||||
uint64_t sfp_maxbw; /* bandwidth limit in bps */
|
||||
int sfp_status; /* flow create status for getsockopt */
|
||||
} sock_flow_props_t;
|
||||
|
||||
#define SOCK_FLOW_PROP_VERSION1 1
|
||||
|
||||
/* bit mask values for sfp_mask */
|
||||
#define SFP_MAXBW 0x00000001 /* Flow Bandwidth Limit */
|
||||
#define SFP_PRIORITY 0x00000008 /* Flow priority */
|
||||
|
||||
/* possible values for sfp_priority */
|
||||
#define SFP_PRIO_NORMAL 1
|
||||
#define SFP_PRIO_HIGH 2
|
||||
|
||||
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
|
||||
#pragma pack()
|
||||
#endif /* _LONG_LONG_ALIGNMENT */
|
||||
|
||||
#endif /* SO_FLOW_SLA */
|
||||
#endif /* __solaris__ */
|
||||
|
||||
JNIEXPORT jboolean JNICALL NET_IsFlowSupported();
|
||||
|
||||
#endif /* NET_UTILS_MD_H */
|
||||
|
@ -52,7 +52,6 @@ import sun.awt.*;
|
||||
import sun.awt.datatransfer.DataTransferer;
|
||||
import sun.font.FontConfigManager;
|
||||
import sun.java2d.SunGraphicsEnvironment;
|
||||
import sun.misc.*;
|
||||
import sun.awt.util.PerformanceLogger;
|
||||
import sun.awt.util.ThreadGroupUtils;
|
||||
import sun.print.PrintJob2D;
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2010, 2016, 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
|
||||
@ -72,8 +72,8 @@ typedef struct _XRadialGradient {
|
||||
|
||||
#include <dlfcn.h>
|
||||
|
||||
#if defined(__solaris__) || defined(_AIX)
|
||||
/* Solaris 10 and AIX will not have these symbols at runtime */
|
||||
#if defined(__solaris__)
|
||||
/* Solaris 10 will not have these symbols at compile time */
|
||||
|
||||
typedef Picture (*XRenderCreateLinearGradientFuncType)
|
||||
(Display *dpy,
|
||||
@ -147,7 +147,22 @@ static jboolean IsXRenderAvailable(jboolean verbose, jboolean ignoreLinuxVersion
|
||||
return JNI_FALSE;
|
||||
}
|
||||
|
||||
#if defined(__solaris__) || defined(_AIX)
|
||||
#if defined(_AIX)
|
||||
// On AIX we have to use a special syntax because the shared libraries are packed in
|
||||
// multi-architecture archives. We first try to load the system default libXrender
|
||||
// which is contained in the 'X11.base.lib' fileset starting with AIX 6.1
|
||||
xrenderlib = dlopen("libXrender.a(shr_64.o)", RTLD_GLOBAL | RTLD_LAZY | RTLD_MEMBER);
|
||||
if (xrenderlib == NULL) {
|
||||
// If the latter wasn't successful, we also try to load the version under /opt/freeware
|
||||
// This may be downloaded from the "AIX Toolbox for Linux Applications" even for AIX 5.3
|
||||
xrenderlib = dlopen("libXrender.a(libXrender.so.0)", RTLD_GLOBAL | RTLD_LAZY | RTLD_MEMBER);
|
||||
}
|
||||
if (xrenderlib != NULL) {
|
||||
dlclose(xrenderlib);
|
||||
} else {
|
||||
available = JNI_FALSE;
|
||||
}
|
||||
#elif defined(__solaris__)
|
||||
xrenderlib = dlopen("libXrender.so",RTLD_GLOBAL|RTLD_LAZY);
|
||||
if (xrenderlib != NULL) {
|
||||
|
||||
|
@ -43,6 +43,8 @@ import java.util.stream.Stream;
|
||||
import jdk.internal.misc.JavaAWTAccess;
|
||||
import jdk.internal.misc.SharedSecrets;
|
||||
import sun.util.logging.internal.LoggingProviderImpl;
|
||||
import java.lang.reflect.Module;
|
||||
import static jdk.internal.logger.DefaultLoggerFinder.isSystem;
|
||||
|
||||
/**
|
||||
* There is a single global LogManager object that is used to
|
||||
@ -503,10 +505,16 @@ public class LogManager {
|
||||
// as a LogManager subclass may override the addLogger, getLogger,
|
||||
// readConfiguration, and other methods.
|
||||
Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
|
||||
final Module module = caller == null ? null : caller.getModule();
|
||||
return demandLogger(name, resourceBundleName, module);
|
||||
}
|
||||
|
||||
Logger demandLogger(String name, String resourceBundleName, Module module) {
|
||||
Logger result = getLogger(name);
|
||||
if (result == null) {
|
||||
// only allocate the new logger once
|
||||
Logger newLogger = new Logger(name, resourceBundleName, caller, this, false);
|
||||
Logger newLogger = new Logger(name, resourceBundleName,
|
||||
module == null ? null : module, this, false);
|
||||
do {
|
||||
if (addLogger(newLogger)) {
|
||||
// We successfully added the new Logger that we
|
||||
@ -532,9 +540,14 @@ public class LogManager {
|
||||
}
|
||||
|
||||
Logger demandSystemLogger(String name, String resourceBundleName, Class<?> caller) {
|
||||
final Module module = caller == null ? null : caller.getModule();
|
||||
return demandSystemLogger(name, resourceBundleName, module);
|
||||
}
|
||||
|
||||
Logger demandSystemLogger(String name, String resourceBundleName, Module module) {
|
||||
// Add a system logger in the system context's namespace
|
||||
final Logger sysLogger = getSystemContext()
|
||||
.demandLogger(name, resourceBundleName, caller);
|
||||
.demandLogger(name, resourceBundleName, module);
|
||||
|
||||
// Add the system logger to the LogManager's namespace if not exist
|
||||
// so that there is only one single logger of the given name.
|
||||
@ -619,11 +632,11 @@ public class LogManager {
|
||||
return global;
|
||||
}
|
||||
|
||||
Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
|
||||
Logger demandLogger(String name, String resourceBundleName, Module module) {
|
||||
// a LogManager subclass may have its own implementation to add and
|
||||
// get a Logger. So delegate to the LogManager to do the work.
|
||||
final LogManager owner = getOwner();
|
||||
return owner.demandLogger(name, resourceBundleName, caller);
|
||||
return owner.demandLogger(name, resourceBundleName, module);
|
||||
}
|
||||
|
||||
|
||||
@ -907,11 +920,13 @@ public class LogManager {
|
||||
// one single logger of the given name. System loggers are visible
|
||||
// to applications unless a logger of the same name has been added.
|
||||
@Override
|
||||
Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
|
||||
Logger demandLogger(String name, String resourceBundleName,
|
||||
Module module) {
|
||||
Logger result = findLogger(name);
|
||||
if (result == null) {
|
||||
// only allocate the new system logger once
|
||||
Logger newLogger = new Logger(name, resourceBundleName, caller, getOwner(), true);
|
||||
Logger newLogger = new Logger(name, resourceBundleName,
|
||||
module, getOwner(), true);
|
||||
do {
|
||||
if (addLocalLogger(newLogger)) {
|
||||
// We successfully added the new Logger that we
|
||||
@ -2622,18 +2637,18 @@ public class LogManager {
|
||||
}
|
||||
|
||||
/**
|
||||
* Demands a logger on behalf of the given {@code caller}.
|
||||
* Demands a logger on behalf of the given {@code module}.
|
||||
* <p>
|
||||
* If a named logger suitable for the given caller is found
|
||||
* If a named logger suitable for the given module is found
|
||||
* returns it.
|
||||
* Otherwise, creates a new logger suitable for the given caller.
|
||||
* Otherwise, creates a new logger suitable for the given module.
|
||||
*
|
||||
* @param name The logger name.
|
||||
* @param caller The caller on which behalf the logger is created/retrieved.
|
||||
* @return A logger for the given {@code caller}.
|
||||
* @param module The module on which behalf the logger is created/retrieved.
|
||||
* @return A logger for the given {@code module}.
|
||||
*
|
||||
* @throws NullPointerException if {@code name} is {@code null}
|
||||
* or {@code caller} is {@code null}.
|
||||
* or {@code module} is {@code null}.
|
||||
* @throws IllegalArgumentException if {@code manager} is not the default
|
||||
* LogManager.
|
||||
* @throws SecurityException if a security manager is present and the
|
||||
@ -2641,7 +2656,7 @@ public class LogManager {
|
||||
* {@link LoggingPermission LoggingPermission("demandLogger", null)}.
|
||||
*/
|
||||
@Override
|
||||
public Logger demandLoggerFor(LogManager manager, String name, /* Module */ Class<?> caller) {
|
||||
public Logger demandLoggerFor(LogManager manager, String name, Module module) {
|
||||
if (manager != getLogManager()) {
|
||||
// having LogManager as parameter just ensures that the
|
||||
// caller will have initialized the LogManager before reaching
|
||||
@ -2649,15 +2664,16 @@ public class LogManager {
|
||||
throw new IllegalArgumentException("manager");
|
||||
}
|
||||
Objects.requireNonNull(name);
|
||||
Objects.requireNonNull(module);
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(controlPermission);
|
||||
}
|
||||
if (caller.getClassLoader() == null) {
|
||||
if (isSystem(module)) {
|
||||
return manager.demandSystemLogger(name,
|
||||
Logger.SYSTEM_LOGGER_RB_NAME, caller);
|
||||
Logger.SYSTEM_LOGGER_RB_NAME, module);
|
||||
} else {
|
||||
return manager.demandLogger(name, null, caller);
|
||||
return manager.demandLogger(name, null, module);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -40,6 +40,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
|
||||
import java.util.function.Supplier;
|
||||
import jdk.internal.reflect.CallerSensitive;
|
||||
import jdk.internal.reflect.Reflection;
|
||||
import static jdk.internal.logger.DefaultLoggerFinder.isSystem;
|
||||
|
||||
/**
|
||||
* A Logger object is used to log messages for a specific
|
||||
@ -379,7 +380,8 @@ public class Logger {
|
||||
this(name, resourceBundleName, null, LogManager.getLogManager(), false);
|
||||
}
|
||||
|
||||
Logger(String name, String resourceBundleName, Class<?> caller, LogManager manager, boolean isSystemLogger) {
|
||||
Logger(String name, String resourceBundleName, Module caller,
|
||||
LogManager manager, boolean isSystemLogger) {
|
||||
this.manager = manager;
|
||||
this.isSystemLogger = isSystemLogger;
|
||||
setupResourceInfo(resourceBundleName, caller);
|
||||
@ -387,10 +389,7 @@ public class Logger {
|
||||
levelValue = Level.INFO.intValue();
|
||||
}
|
||||
|
||||
private void setCallerModuleRef(Class<?> caller) {
|
||||
Module callerModule = ((caller != null)
|
||||
? caller.getModule()
|
||||
: null);
|
||||
private void setCallerModuleRef(Module callerModule) {
|
||||
if (callerModule != null) {
|
||||
this.callerModuleRef = new WeakReference<>(callerModule);
|
||||
}
|
||||
@ -618,7 +617,7 @@ public class Logger {
|
||||
// all loggers in the system context will default to
|
||||
// the system logger's resource bundle - therefore the caller won't
|
||||
// be needed and can be null.
|
||||
Logger result = manager.demandSystemLogger(name, SYSTEM_LOGGER_RB_NAME, null);
|
||||
Logger result = manager.demandSystemLogger(name, SYSTEM_LOGGER_RB_NAME, (Module)null);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -681,8 +680,10 @@ public class Logger {
|
||||
LogManager manager = LogManager.getLogManager();
|
||||
// cleanup some Loggers that have been GC'ed
|
||||
manager.drainLoggerRefQueueBounded();
|
||||
final Class<?> callerClass = Reflection.getCallerClass();
|
||||
final Module module = callerClass.getModule();
|
||||
Logger result = new Logger(null, resourceBundleName,
|
||||
Reflection.getCallerClass(), manager, false);
|
||||
module, manager, false);
|
||||
result.anonymous = true;
|
||||
Logger root = manager.getLogger("");
|
||||
result.doSetParent(root);
|
||||
@ -2046,6 +2047,11 @@ public class Logger {
|
||||
}
|
||||
}
|
||||
|
||||
private void setupResourceInfo(String name, Class<?> caller) {
|
||||
final Module module = caller == null ? null : caller.getModule();
|
||||
setupResourceInfo(name, module);
|
||||
}
|
||||
|
||||
// Private utility method to initialize our one entry
|
||||
// resource bundle name cache and the callers Module
|
||||
// Note: for consistency reasons, we are careful to check
|
||||
@ -2053,7 +2059,7 @@ public class Logger {
|
||||
// resourceBundleName field.
|
||||
// Synchronized to prevent races in setting the fields.
|
||||
private synchronized void setupResourceInfo(String name,
|
||||
Class<?> callerClass) {
|
||||
Module callerModule) {
|
||||
final LoggerBundle lb = loggerBundle;
|
||||
if (lb.resourceBundleName != null) {
|
||||
// this Logger already has a ResourceBundle
|
||||
@ -2072,8 +2078,9 @@ public class Logger {
|
||||
return;
|
||||
}
|
||||
|
||||
setCallerModuleRef(callerClass);
|
||||
if (isSystemLogger && (callerClass != null && callerClass.getClassLoader() != null)) {
|
||||
setCallerModuleRef(callerModule);
|
||||
|
||||
if (isSystemLogger && (callerModule != null && !isSystem(callerModule))) {
|
||||
checkPermission();
|
||||
}
|
||||
|
||||
|
@ -32,6 +32,7 @@ import java.util.ResourceBundle;
|
||||
import java.util.function.Supplier;
|
||||
import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.reflect.Module;
|
||||
import java.util.Objects;
|
||||
import java.util.logging.LogManager;
|
||||
import jdk.internal.logger.DefaultLoggerFinder;
|
||||
@ -398,21 +399,20 @@ public final class LoggingProviderImpl extends DefaultLoggerFinder {
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a java.util.logging.Logger for the given caller.
|
||||
* Creates a java.util.logging.Logger for the given module.
|
||||
* @param name the logger name.
|
||||
* @param caller the caller for which the logger should be created.
|
||||
* @return a Logger suitable for use in the given caller.
|
||||
* @param module the module for which the logger should be created.
|
||||
* @return a Logger suitable for use in the given module.
|
||||
*/
|
||||
private static java.util.logging.Logger demandJULLoggerFor(final String name,
|
||||
/* Module */
|
||||
final Class<?> caller) {
|
||||
Module module) {
|
||||
final LogManager manager = LogManager.getLogManager();
|
||||
final SecurityManager sm = System.getSecurityManager();
|
||||
if (sm == null) {
|
||||
return logManagerAccess.demandLoggerFor(manager, name, caller);
|
||||
return logManagerAccess.demandLoggerFor(manager, name, module);
|
||||
} else {
|
||||
final PrivilegedAction<java.util.logging.Logger> pa =
|
||||
() -> logManagerAccess.demandLoggerFor(manager, name, caller);
|
||||
() -> logManagerAccess.demandLoggerFor(manager, name, module);
|
||||
return AccessController.doPrivileged(pa, null, LOGGING_CONTROL_PERMISSION);
|
||||
}
|
||||
}
|
||||
@ -429,17 +429,17 @@ public final class LoggingProviderImpl extends DefaultLoggerFinder {
|
||||
* {@code RuntimePermission("loggerFinder")}.
|
||||
*/
|
||||
@Override
|
||||
protected Logger demandLoggerFor(String name, /* Module */ Class<?> caller) {
|
||||
protected Logger demandLoggerFor(String name, Module module) {
|
||||
final SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
}
|
||||
return JULWrapper.of(demandJULLoggerFor(name,caller));
|
||||
return JULWrapper.of(demandJULLoggerFor(name,module));
|
||||
}
|
||||
|
||||
public static interface LogManagerAccess {
|
||||
java.util.logging.Logger demandLoggerFor(LogManager manager,
|
||||
String name, /* Module */ Class<?> caller);
|
||||
String name, Module module);
|
||||
}
|
||||
|
||||
// Hook for tests
|
||||
|
@ -61,24 +61,32 @@ public final class ImageLocationWriter extends ImageLocation {
|
||||
String baseName;
|
||||
String extensionName = "";
|
||||
|
||||
int offset = fullName.indexOf('/', 1);
|
||||
if (fullName.length() >= 2 && fullName.charAt(0) == '/' && offset != -1) {
|
||||
moduleName = fullName.substring(1, offset);
|
||||
fullName = fullName.substring(offset + 1);
|
||||
}
|
||||
|
||||
offset = fullName.lastIndexOf('/');
|
||||
if (1 < offset) {
|
||||
parentName = fullName.substring(0, offset);
|
||||
fullName = fullName.substring(offset + 1);
|
||||
}
|
||||
|
||||
offset = fullName.lastIndexOf('.');
|
||||
if (offset != -1) {
|
||||
baseName = fullName.substring(0, offset);
|
||||
extensionName = fullName.substring(offset + 1);
|
||||
if (fullName.startsWith("/modules/")) {
|
||||
moduleName = "modules";
|
||||
baseName = fullName.substring("/modules/".length());
|
||||
} else if ( fullName.startsWith("/packages/")) {
|
||||
moduleName = "packages";
|
||||
baseName = fullName.substring("/packages/".length());
|
||||
} else {
|
||||
baseName = fullName;
|
||||
int offset = fullName.indexOf('/', 1);
|
||||
if (fullName.length() >= 2 && fullName.charAt(0) == '/' && offset != -1) {
|
||||
moduleName = fullName.substring(1, offset);
|
||||
fullName = fullName.substring(offset + 1);
|
||||
}
|
||||
|
||||
offset = fullName.lastIndexOf('/');
|
||||
if (1 < offset) {
|
||||
parentName = fullName.substring(0, offset);
|
||||
fullName = fullName.substring(offset + 1);
|
||||
}
|
||||
|
||||
offset = fullName.lastIndexOf('.');
|
||||
if (offset != -1) {
|
||||
baseName = fullName.substring(0, offset);
|
||||
extensionName = fullName.substring(offset + 1);
|
||||
} else {
|
||||
baseName = fullName;
|
||||
}
|
||||
}
|
||||
|
||||
return new ImageLocationWriter(strings)
|
||||
|
@ -0,0 +1,146 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package jdk.tools.jlink.internal.packager;
|
||||
|
||||
|
||||
import jdk.tools.jlink.Jlink;
|
||||
import jdk.tools.jlink.builder.ImageBuilder;
|
||||
import jdk.tools.jlink.plugin.Plugin;
|
||||
import jdk.tools.jlink.builder.*;
|
||||
import jdk.tools.jlink.plugin.Pool;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.PrintWriter;
|
||||
import java.io.StringReader;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.EnumSet;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import java.util.ResourceBundle;
|
||||
import java.util.Set;
|
||||
import java.util.StringTokenizer;
|
||||
import java.util.TreeSet;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* AppRuntimeImageBuilder is a private API used only by the Java Packager to generate
|
||||
* a Java runtime image using jlink. AppRuntimeImageBuilder encapsulates the
|
||||
* arguments that jlink requires to generate this image. To create the image call the
|
||||
* build() method.
|
||||
*/
|
||||
public final class AppRuntimeImageBuilder {
|
||||
private Path outputDir = null;
|
||||
private List<Path> modulePath = null;
|
||||
private Set<String> addModules = null;
|
||||
private Set<String> limitModules = null;
|
||||
private String excludeFileList = null;
|
||||
private Map<String, String> userArguments = null;
|
||||
private Boolean stripNativeCommands = null;
|
||||
|
||||
public AppRuntimeImageBuilder() {}
|
||||
|
||||
public void setOutputDir(Path value) {
|
||||
outputDir = value;
|
||||
}
|
||||
|
||||
public void setModulePath(List<Path> value) {
|
||||
modulePath = value;
|
||||
}
|
||||
|
||||
public void setAddModules(Set<String> value) {
|
||||
addModules = value;
|
||||
}
|
||||
|
||||
public void setLimitModules(Set<String> value) {
|
||||
limitModules = value;
|
||||
}
|
||||
|
||||
public void setExcludeFileList(String value) {
|
||||
excludeFileList = value;
|
||||
}
|
||||
|
||||
public void setStripNativeCommands(boolean value) {
|
||||
stripNativeCommands = value;
|
||||
}
|
||||
|
||||
public void setUserArguments(Map<String, String> value) {
|
||||
userArguments = value;
|
||||
}
|
||||
|
||||
public void build() throws IOException {
|
||||
// jlink main arguments
|
||||
Jlink.JlinkConfiguration jlinkConfig = new Jlink.JlinkConfiguration(
|
||||
new File("").toPath(), // Unused
|
||||
modulePath, addModules, limitModules);
|
||||
|
||||
// plugin configuration
|
||||
List<Plugin> plugins = new ArrayList<Plugin>();
|
||||
|
||||
if (stripNativeCommands) {
|
||||
plugins.add(Jlink.newPlugin(
|
||||
"strip-native-commands",
|
||||
Collections.singletonMap("strip-native-commands", "on"),
|
||||
null));
|
||||
}
|
||||
|
||||
if (excludeFileList != null && !excludeFileList.isEmpty()) {
|
||||
plugins.add(Jlink.newPlugin(
|
||||
"exclude-files",
|
||||
Collections.singletonMap("exclude-files", excludeFileList),
|
||||
null));
|
||||
}
|
||||
|
||||
// add user supplied jlink arguments
|
||||
for (Map.Entry<String, String> entry : userArguments.entrySet()) {
|
||||
String key = entry.getKey();
|
||||
String value = entry.getValue();
|
||||
plugins.add(Jlink.newPlugin(key,
|
||||
Collections.singletonMap(key, value),
|
||||
null));
|
||||
}
|
||||
|
||||
plugins.add(Jlink.newPlugin("installed-modules", Collections.emptyMap(), null));
|
||||
|
||||
// build the image
|
||||
Jlink.PluginsConfiguration pluginConfig = new Jlink.PluginsConfiguration(
|
||||
plugins, new DefaultImageBuilder(true, outputDir), null);
|
||||
Jlink jlink = new Jlink();
|
||||
jlink.build(jlinkConfig, pluginConfig);
|
||||
}
|
||||
}
|
@ -23,7 +23,7 @@
|
||||
* questions.
|
||||
*/
|
||||
|
||||
module jdk.jvmstat.rmi {
|
||||
module jdk.jstatd {
|
||||
requires java.rmi;
|
||||
requires jdk.jvmstat;
|
||||
|
@ -28,12 +28,12 @@ module jdk.jvmstat {
|
||||
jdk.attach,
|
||||
jdk.jcmd,
|
||||
jdk.jconsole,
|
||||
jdk.jvmstat.rmi;
|
||||
jdk.jstatd;
|
||||
exports sun.jvmstat.monitor.event to
|
||||
jdk.jcmd,
|
||||
jdk.jvmstat.rmi;
|
||||
jdk.jstatd;
|
||||
exports sun.jvmstat.perfdata.monitor to
|
||||
jdk.jvmstat.rmi;
|
||||
jdk.jstatd;
|
||||
|
||||
uses sun.jvmstat.monitor.MonitoredHostService;
|
||||
provides sun.jvmstat.monitor.MonitoredHostService with sun.jvmstat.perfdata.monitor.protocol.file.MonitoredHostFileService;
|
||||
|
212
jdk/src/jdk.net/share/classes/jdk/net/ExtendedSocketOptions.java
Normal file
212
jdk/src/jdk.net/share/classes/jdk/net/ExtendedSocketOptions.java
Normal file
@ -0,0 +1,212 @@
|
||||
/*
|
||||
* Copyright (c) 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
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package jdk.net;
|
||||
|
||||
import java.io.FileDescriptor;
|
||||
import java.net.SocketException;
|
||||
import java.net.SocketOption;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.util.Collections;
|
||||
import java.util.Set;
|
||||
import jdk.internal.misc.JavaIOFileDescriptorAccess;
|
||||
import jdk.internal.misc.SharedSecrets;
|
||||
|
||||
/**
|
||||
* Defines extended socket options, beyond those defined in
|
||||
* {@link java.net.StandardSocketOptions}. These options may be platform
|
||||
* specific.
|
||||
*
|
||||
* @since 1.8
|
||||
*/
|
||||
public final class ExtendedSocketOptions {
|
||||
|
||||
private static class ExtSocketOption<T> implements SocketOption<T> {
|
||||
private final String name;
|
||||
private final Class<T> type;
|
||||
ExtSocketOption(String name, Class<T> type) {
|
||||
this.name = name;
|
||||
this.type = type;
|
||||
}
|
||||
@Override public String name() { return name; }
|
||||
@Override public Class<T> type() { return type; }
|
||||
@Override public String toString() { return name; }
|
||||
}
|
||||
|
||||
private ExtendedSocketOptions() { }
|
||||
|
||||
/**
|
||||
* Service level properties. When a security manager is installed,
|
||||
* setting or getting this option requires a {@link NetworkPermission}
|
||||
* {@code ("setOption.SO_FLOW_SLA")} or {@code "getOption.SO_FLOW_SLA"}
|
||||
* respectively.
|
||||
*/
|
||||
public static final SocketOption<SocketFlow> SO_FLOW_SLA = new
|
||||
ExtSocketOption<SocketFlow>("SO_FLOW_SLA", SocketFlow.class);
|
||||
|
||||
|
||||
private static final PlatformSocketOptions platformSocketOptions =
|
||||
PlatformSocketOptions.get();
|
||||
|
||||
private static final boolean flowSupported =
|
||||
platformSocketOptions.flowSupported();
|
||||
|
||||
private static final Set<SocketOption<?>> extendedOptions = options();
|
||||
|
||||
static Set<SocketOption<?>> options() {
|
||||
if (flowSupported)
|
||||
return Set.of(SO_FLOW_SLA);
|
||||
else
|
||||
return Collections.<SocketOption<?>>emptySet();
|
||||
}
|
||||
|
||||
static {
|
||||
// Registers the extended socket options with the base module.
|
||||
sun.net.ext.ExtendedSocketOptions.register(
|
||||
new sun.net.ext.ExtendedSocketOptions(extendedOptions) {
|
||||
|
||||
@Override
|
||||
public void setOption(FileDescriptor fd,
|
||||
SocketOption<?> option,
|
||||
Object value)
|
||||
throws SocketException
|
||||
{
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null)
|
||||
sm.checkPermission(new NetworkPermission("setOption." + option.name()));
|
||||
|
||||
if (fd == null || !fd.valid())
|
||||
throw new SocketException("socket closed");
|
||||
|
||||
if (option == SO_FLOW_SLA) {
|
||||
assert flowSupported;
|
||||
SocketFlow flow = checkValueType(value, option.type());
|
||||
setFlowOption(fd, flow);
|
||||
} else {
|
||||
throw new InternalError("Unexpected option " + option);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getOption(FileDescriptor fd,
|
||||
SocketOption<?> option)
|
||||
throws SocketException
|
||||
{
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null)
|
||||
sm.checkPermission(new NetworkPermission("getOption." + option.name()));
|
||||
|
||||
if (fd == null || !fd.valid())
|
||||
throw new SocketException("socket closed");
|
||||
|
||||
if (option == SO_FLOW_SLA) {
|
||||
assert flowSupported;
|
||||
SocketFlow flow = SocketFlow.create();
|
||||
getFlowOption(fd, flow);
|
||||
return flow;
|
||||
} else {
|
||||
throw new InternalError("Unexpected option " + option);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static <T> T checkValueType(Object value, Class<?> type) {
|
||||
if (!type.isAssignableFrom(value.getClass())) {
|
||||
String s = "Found: " + value.getClass() + ", Expected: " + type;
|
||||
throw new IllegalArgumentException(s);
|
||||
}
|
||||
return (T) value;
|
||||
}
|
||||
|
||||
private static final JavaIOFileDescriptorAccess fdAccess =
|
||||
SharedSecrets.getJavaIOFileDescriptorAccess();
|
||||
|
||||
private static void setFlowOption(FileDescriptor fd, SocketFlow f)
|
||||
throws SocketException
|
||||
{
|
||||
int status = platformSocketOptions.setFlowOption(fdAccess.get(fd),
|
||||
f.priority(),
|
||||
f.bandwidth());
|
||||
f.status(status); // augment the given flow with the status
|
||||
}
|
||||
|
||||
private static void getFlowOption(FileDescriptor fd, SocketFlow f)
|
||||
throws SocketException
|
||||
{
|
||||
int status = platformSocketOptions.getFlowOption(fdAccess.get(fd), f);
|
||||
f.status(status); // augment the given flow with the status
|
||||
}
|
||||
|
||||
static class PlatformSocketOptions {
|
||||
|
||||
protected PlatformSocketOptions() {}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static PlatformSocketOptions newInstance(String cn) {
|
||||
Class<PlatformSocketOptions> c;
|
||||
try {
|
||||
c = (Class<PlatformSocketOptions>)Class.forName(cn);
|
||||
return c.getConstructor(new Class<?>[] { }).newInstance();
|
||||
} catch (ReflectiveOperationException x) {
|
||||
throw new AssertionError(x);
|
||||
}
|
||||
}
|
||||
|
||||
private static PlatformSocketOptions create() {
|
||||
String osname = AccessController.doPrivileged(
|
||||
new PrivilegedAction<String>() {
|
||||
public String run() {
|
||||
return System.getProperty("os.name");
|
||||
}
|
||||
});
|
||||
if ("SunOS".equals(osname))
|
||||
return newInstance("jdk.net.SolarisSocketOptions");
|
||||
return new PlatformSocketOptions();
|
||||
}
|
||||
|
||||
private static final PlatformSocketOptions instance = create();
|
||||
|
||||
static PlatformSocketOptions get() {
|
||||
return instance;
|
||||
}
|
||||
|
||||
int setFlowOption(int fd, int priority, long bandwidth)
|
||||
throws SocketException
|
||||
{
|
||||
throw new UnsupportedOperationException("unsupported socket option");
|
||||
}
|
||||
|
||||
int getFlowOption(int fd, SocketFlow f) throws SocketException {
|
||||
throw new UnsupportedOperationException("unsupported socket option");
|
||||
}
|
||||
|
||||
boolean flowSupported() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
@ -47,17 +47,18 @@ import java.lang.annotation.Native;
|
||||
*/
|
||||
public class SocketFlow {
|
||||
|
||||
private static final int UNSET = -1;
|
||||
@Native public static final int UNSET = -1;
|
||||
@Native public static final int NORMAL_PRIORITY = 1;
|
||||
@Native public static final int HIGH_PRIORITY = 2;
|
||||
|
||||
private int priority = NORMAL_PRIORITY;
|
||||
|
||||
private long bandwidth = UNSET;
|
||||
|
||||
private Status status = Status.NO_STATUS;
|
||||
|
||||
private SocketFlow() {}
|
||||
@Native private static final int NO_STATUS_VALUE = 0;
|
||||
@Native private static final int OK_VALUE = 1;
|
||||
@Native private static final int NO_PERMISSION_VALUE = 2;
|
||||
@Native private static final int NOT_CONNECTED_VALUE = 3;
|
||||
@Native private static final int NOT_SUPPORTED_VALUE = 4;
|
||||
@Native private static final int ALREADY_CREATED_VALUE = 5;
|
||||
@Native private static final int IN_PROGRESS_VALUE = 6;
|
||||
@Native private static final int OTHER_VALUE = 7;
|
||||
|
||||
/**
|
||||
* Enumeration of the return values from the SO_FLOW_SLA
|
||||
@ -72,37 +73,56 @@ public class SocketFlow {
|
||||
* Set or get socket option has not been called yet. Status
|
||||
* values can only be retrieved after calling set or get.
|
||||
*/
|
||||
NO_STATUS,
|
||||
NO_STATUS(NO_STATUS_VALUE),
|
||||
/**
|
||||
* Flow successfully created.
|
||||
*/
|
||||
OK,
|
||||
OK(OK_VALUE),
|
||||
/**
|
||||
* Caller has no permission to create flow.
|
||||
*/
|
||||
NO_PERMISSION,
|
||||
NO_PERMISSION(NO_PERMISSION_VALUE),
|
||||
/**
|
||||
* Flow can not be created because socket is not connected.
|
||||
*/
|
||||
NOT_CONNECTED,
|
||||
NOT_CONNECTED(NOT_CONNECTED_VALUE),
|
||||
/**
|
||||
* Flow creation not supported for this socket.
|
||||
*/
|
||||
NOT_SUPPORTED,
|
||||
NOT_SUPPORTED(NOT_SUPPORTED_VALUE),
|
||||
/**
|
||||
* A flow already exists with identical attributes.
|
||||
*/
|
||||
ALREADY_CREATED,
|
||||
ALREADY_CREATED(ALREADY_CREATED_VALUE),
|
||||
/**
|
||||
* A flow is being created.
|
||||
*/
|
||||
IN_PROGRESS,
|
||||
IN_PROGRESS(IN_PROGRESS_VALUE),
|
||||
/**
|
||||
* Some other unspecified error.
|
||||
*/
|
||||
OTHER
|
||||
OTHER(OTHER_VALUE);
|
||||
|
||||
private final int value;
|
||||
Status(int value) { this.value = value; }
|
||||
|
||||
static Status from(int value) {
|
||||
if (value == NO_STATUS.value) return NO_STATUS;
|
||||
else if (value == OK.value) return OK;
|
||||
else if (value == NO_PERMISSION.value) return NO_PERMISSION;
|
||||
else if (value == NOT_CONNECTED.value) return NOT_CONNECTED;
|
||||
else if (value == NOT_SUPPORTED.value) return NOT_SUPPORTED;
|
||||
else if (value == ALREADY_CREATED.value) return ALREADY_CREATED;
|
||||
else if (value == IN_PROGRESS.value) return IN_PROGRESS;
|
||||
else if (value == OTHER.value) return OTHER;
|
||||
else throw new InternalError("Unknown value: " + value);
|
||||
}
|
||||
}
|
||||
|
||||
private int priority = NORMAL_PRIORITY;
|
||||
private long bandwidth = UNSET;
|
||||
private Status status = Status.NO_STATUS;
|
||||
|
||||
/**
|
||||
* Creates a new SocketFlow that can be used to set the SO_FLOW_SLA
|
||||
* socket option and create a socket flow.
|
||||
@ -111,6 +131,8 @@ public class SocketFlow {
|
||||
return new SocketFlow();
|
||||
}
|
||||
|
||||
private SocketFlow() { }
|
||||
|
||||
/**
|
||||
* Sets this SocketFlow's priority. Must be either NORMAL_PRIORITY
|
||||
* HIGH_PRIORITY. If not set, a flow's priority is normal.
|
||||
@ -119,9 +141,8 @@ public class SocketFlow {
|
||||
* HIGH_PRIORITY.
|
||||
*/
|
||||
public SocketFlow priority(int priority) {
|
||||
if (priority != NORMAL_PRIORITY && priority != HIGH_PRIORITY) {
|
||||
throw new IllegalArgumentException("invalid priority");
|
||||
}
|
||||
if (priority != NORMAL_PRIORITY && priority != HIGH_PRIORITY)
|
||||
throw new IllegalArgumentException("invalid priority :" + priority);
|
||||
this.priority = priority;
|
||||
return this;
|
||||
}
|
||||
@ -133,11 +154,9 @@ public class SocketFlow {
|
||||
* @throws IllegalArgumentException if bandwidth is less than zero.
|
||||
*/
|
||||
public SocketFlow bandwidth(long bandwidth) {
|
||||
if (bandwidth < 0) {
|
||||
throw new IllegalArgumentException("invalid bandwidth");
|
||||
} else {
|
||||
this.bandwidth = bandwidth;
|
||||
}
|
||||
if (bandwidth < 0)
|
||||
throw new IllegalArgumentException("invalid bandwidth: " + bandwidth);
|
||||
this.bandwidth = bandwidth;
|
||||
return this;
|
||||
}
|
||||
|
||||
@ -164,4 +183,18 @@ public class SocketFlow {
|
||||
public Status status() {
|
||||
return status;
|
||||
}
|
||||
|
||||
void status(int status) {
|
||||
this.status = Status.from(status);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder(super.toString());
|
||||
sb.append(" [ priority=").append(priority())
|
||||
.append(", bandwidth=").append(bandwidth())
|
||||
.append(", status=").append(status())
|
||||
.append(" ]");
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
@ -27,15 +27,12 @@ package jdk.net;
|
||||
|
||||
import java.net.*;
|
||||
import java.io.IOException;
|
||||
import java.io.FileDescriptor;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.security.AccessController;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.Set;
|
||||
import java.util.HashSet;
|
||||
import java.util.HashMap;
|
||||
import java.util.Collections;
|
||||
import sun.net.ExtendedOptionsImpl;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import jdk.net.ExtendedSocketOptions.PlatformSocketOptions;
|
||||
|
||||
/**
|
||||
* Defines static methods to set and get socket options defined by the
|
||||
@ -57,12 +54,8 @@ import sun.net.ExtendedOptionsImpl;
|
||||
*/
|
||||
public class Sockets {
|
||||
|
||||
private static final HashMap<Class<?>,Set<SocketOption<?>>>
|
||||
options = new HashMap<>();
|
||||
|
||||
static {
|
||||
initOptionSets();
|
||||
}
|
||||
private static final Map<Class<?>,Set<SocketOption<?>>>
|
||||
options = optionSets();
|
||||
|
||||
private Sockets() {}
|
||||
|
||||
@ -259,14 +252,16 @@ public class Sockets {
|
||||
*/
|
||||
static boolean isReusePortAvailable() {
|
||||
if (!checkedReusePort) {
|
||||
isReusePortAvailable = isReusePortAvailable0();
|
||||
Set<SocketOption<?>> s = new Socket().supportedOptions();
|
||||
isReusePortAvailable = s.contains(StandardSocketOptions.SO_REUSEPORT);
|
||||
checkedReusePort = true;
|
||||
}
|
||||
return isReusePortAvailable;
|
||||
}
|
||||
|
||||
private static void initOptionSets() {
|
||||
boolean flowsupported = ExtendedOptionsImpl.flowSupported();
|
||||
private static Map<Class<?>,Set<SocketOption<?>>> optionSets() {
|
||||
Map<Class<?>,Set<SocketOption<?>>> options = new HashMap<>();
|
||||
boolean flowsupported = PlatformSocketOptions.get().flowSupported();
|
||||
boolean reuseportsupported = isReusePortAvailable();
|
||||
// Socket
|
||||
|
||||
@ -333,7 +328,7 @@ public class Sockets {
|
||||
}
|
||||
set = Collections.unmodifiableSet(set);
|
||||
options.put(MulticastSocket.class, set);
|
||||
}
|
||||
|
||||
private static native boolean isReusePortAvailable0();
|
||||
return Collections.unmodifiableMap(options);
|
||||
}
|
||||
}
|
29
jdk/src/jdk.net/share/classes/module-info.java
Normal file
29
jdk/src/jdk.net/share/classes/module-info.java
Normal file
@ -0,0 +1,29 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
module jdk.net {
|
||||
exports jdk.net;
|
||||
}
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2016, 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
|
||||
@ -23,43 +23,34 @@
|
||||
* questions.
|
||||
*/
|
||||
|
||||
#include <jni.h>
|
||||
#include <string.h>
|
||||
package jdk.net;
|
||||
|
||||
#include "net_util.h"
|
||||
import java.net.SocketException;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import jdk.net.ExtendedSocketOptions.PlatformSocketOptions;
|
||||
|
||||
/*
|
||||
* Class: sun_net_ExtendedOptionsImpl
|
||||
* Method: init
|
||||
* Signature: ()V
|
||||
*/
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_init
|
||||
(JNIEnv *env, jclass UNUSED)
|
||||
{
|
||||
}
|
||||
|
||||
/* Non Solaris. Functionality is not supported. So, throw UnsupportedOpExc */
|
||||
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_setFlowOption
|
||||
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow)
|
||||
{
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
}
|
||||
|
||||
JNIEXPORT void JNICALL Java_sun_net_ExtendedOptionsImpl_getFlowOption
|
||||
(JNIEnv *env, jclass UNUSED, jobject fileDesc, jobject flow)
|
||||
{
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
}
|
||||
|
||||
static jboolean flowSupported0() {
|
||||
return JNI_FALSE;
|
||||
}
|
||||
|
||||
JNIEXPORT jboolean JNICALL Java_sun_net_ExtendedOptionsImpl_flowSupported
|
||||
(JNIEnv *env, jclass UNUSED)
|
||||
{
|
||||
return JNI_FALSE;
|
||||
class SolarisSocketOptions extends PlatformSocketOptions {
|
||||
|
||||
public SolarisSocketOptions() { }
|
||||
|
||||
@Override native int setFlowOption(int fd, int priority, long bandwidth)
|
||||
throws SocketException;
|
||||
|
||||
@Override native int getFlowOption(int fd, SocketFlow f)
|
||||
throws SocketException;
|
||||
|
||||
@Override native boolean flowSupported();
|
||||
|
||||
private static native void init();
|
||||
|
||||
static {
|
||||
AccessController.doPrivileged(new PrivilegedAction<Void>() {
|
||||
public Void run() {
|
||||
System.loadLibrary("extnet");
|
||||
return null;
|
||||
}
|
||||
});
|
||||
init();
|
||||
}
|
||||
}
|
176
jdk/src/jdk.net/solaris/native/libextnet/SolarisSocketOptions.c
Normal file
176
jdk/src/jdk.net/solaris/native/libextnet/SolarisSocketOptions.c
Normal file
@ -0,0 +1,176 @@
|
||||
/*
|
||||
* Copyright (c) 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
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
||||
#include "SolarisSocketOptions.h"
|
||||
|
||||
static jfieldID sf_priority;
|
||||
static jfieldID sf_bandwidth;
|
||||
|
||||
static int initialized = 0;
|
||||
|
||||
/*
|
||||
* Class: jdk_net_SolarisSocketOptions
|
||||
* Method: init
|
||||
* Signature: ()V
|
||||
*/
|
||||
JNIEXPORT void JNICALL Java_jdk_net_SolarisSocketOptions_init
|
||||
(JNIEnv *env, jclass unused)
|
||||
{
|
||||
if (!initialized) {
|
||||
jclass c = (*env)->FindClass(env, "jdk/net/SocketFlow");
|
||||
CHECK_NULL(c);
|
||||
sf_priority = (*env)->GetFieldID(env, c, "priority", "I");
|
||||
CHECK_NULL(sf_priority);
|
||||
sf_bandwidth = (*env)->GetFieldID(env, c, "bandwidth", "J");
|
||||
CHECK_NULL(sf_bandwidth);
|
||||
initialized = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/** Return the Status value. */
|
||||
static jint toStatus(int errval)
|
||||
{
|
||||
switch (errval) {
|
||||
case 0: return jdk_net_SocketFlow_OK_VALUE;
|
||||
case EPERM: return jdk_net_SocketFlow_NO_PERMISSION_VALUE;
|
||||
case ENOTCONN: return jdk_net_SocketFlow_NOT_CONNECTED_VALUE;
|
||||
case EOPNOTSUPP: return jdk_net_SocketFlow_NOT_SUPPORTED_VALUE;
|
||||
case EALREADY: return jdk_net_SocketFlow_ALREADY_CREATED_VALUE;
|
||||
case EINPROGRESS: return jdk_net_SocketFlow_IN_PROGRESS_VALUE;
|
||||
default: return jdk_net_SocketFlow_OTHER_VALUE;
|
||||
}
|
||||
}
|
||||
|
||||
void throwByNameWithLastError
|
||||
(JNIEnv *env, const char *name, const char *defaultDetail)
|
||||
{
|
||||
char defaultMsg[255];
|
||||
sprintf(defaultMsg, "errno: %d, %s", errno, defaultDetail);
|
||||
JNU_ThrowByNameWithLastError(env, name, defaultMsg);
|
||||
}
|
||||
|
||||
/*
|
||||
* Class: jdk_net_SolarisSocketOptions
|
||||
* Method: setFlowOption0
|
||||
* Signature: (IIJ)I
|
||||
*/
|
||||
JNIEXPORT jint JNICALL Java_jdk_net_SolarisSocketOptions_setFlowOption
|
||||
(JNIEnv *env, jobject unused, jint fd, jint priority, jlong bandwidth)
|
||||
{
|
||||
int rv;
|
||||
sock_flow_props_t props;
|
||||
memset(&props, 0, sizeof(props));
|
||||
props.sfp_version = SOCK_FLOW_PROP_VERSION1;
|
||||
|
||||
if (priority != jdk_net_SocketFlow_UNSET) {
|
||||
props.sfp_mask |= SFP_PRIORITY;
|
||||
props.sfp_priority = priority;
|
||||
}
|
||||
if (bandwidth > jdk_net_SocketFlow_UNSET) {
|
||||
props.sfp_mask |= SFP_MAXBW;
|
||||
props.sfp_maxbw = (uint64_t) bandwidth;
|
||||
}
|
||||
|
||||
rv = setsockopt(fd, SOL_SOCKET, SO_FLOW_SLA, &props, sizeof(props));
|
||||
|
||||
if (rv < 0) {
|
||||
if (errno == ENOPROTOOPT) {
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
} else if (errno == EACCES || errno == EPERM) {
|
||||
JNU_ThrowByName(env, "java/net/SocketException", "Permission denied");
|
||||
} else {
|
||||
throwByNameWithLastError(env, "java/net/SocketException",
|
||||
"set option SO_FLOW_SLA failed");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return toStatus(props.sfp_status);
|
||||
}
|
||||
|
||||
/*
|
||||
* Class: jdk_net_SolarisSocketOptions
|
||||
* Method: getFlowOption0
|
||||
* Signature: (ILjdk/net/SocketFlow;)I
|
||||
*/
|
||||
JNIEXPORT jint JNICALL Java_jdk_net_SolarisSocketOptions_getFlowOption
|
||||
(JNIEnv *env, jobject unused, jint fd, jobject flow)
|
||||
{
|
||||
sock_flow_props_t props;
|
||||
socklen_t sz = sizeof(props);
|
||||
|
||||
int rv = getsockopt(fd, SOL_SOCKET, SO_FLOW_SLA, &props, &sz);
|
||||
|
||||
if (rv < 0) {
|
||||
if (errno == ENOPROTOOPT) {
|
||||
JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",
|
||||
"unsupported socket option");
|
||||
} else if (errno == EACCES || errno == EPERM) {
|
||||
JNU_ThrowByName(env, "java/net/SocketException", "Permission denied");
|
||||
} else {
|
||||
throwByNameWithLastError(env, "java/net/SocketException",
|
||||
"get option SO_FLOW_SLA failed");
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
/* first check status to see if flow exists */
|
||||
if (props.sfp_status == 0) { /* OK */
|
||||
/* can set the other fields now */
|
||||
if (props.sfp_mask & SFP_PRIORITY) {
|
||||
(*env)->SetIntField(env, flow, sf_priority, props.sfp_priority);
|
||||
}
|
||||
if (props.sfp_mask & SFP_MAXBW) {
|
||||
(*env)->SetLongField(env, flow, sf_bandwidth,
|
||||
(jlong)props.sfp_maxbw);
|
||||
}
|
||||
}
|
||||
return toStatus(props.sfp_status);
|
||||
}
|
||||
|
||||
JNIEXPORT jboolean JNICALL Java_jdk_net_SolarisSocketOptions_flowSupported
|
||||
(JNIEnv *env, jobject unused)
|
||||
{
|
||||
/* Do a simple dummy call, and try to figure out from that */
|
||||
sock_flow_props_t props;
|
||||
int rv, s;
|
||||
|
||||
s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (s < 0) {
|
||||
return JNI_FALSE;
|
||||
}
|
||||
memset(&props, 0, sizeof(props));
|
||||
props.sfp_version = SOCK_FLOW_PROP_VERSION1;
|
||||
props.sfp_mask |= SFP_PRIORITY;
|
||||
props.sfp_priority = SFP_PRIO_NORMAL;
|
||||
rv = setsockopt(s, SOL_SOCKET, SO_FLOW_SLA, &props, sizeof(props));
|
||||
if (rv != 0 && errno == ENOPROTOOPT) {
|
||||
rv = JNI_FALSE;
|
||||
} else {
|
||||
rv = JNI_TRUE;
|
||||
}
|
||||
close(s);
|
||||
return rv;
|
||||
}
|
@ -0,0 +1,79 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef SOLARIS_SOCKET_OPTIONS_H
|
||||
#define SOLARIS_SOCKET_OPTIONS_H
|
||||
|
||||
#include <sys/socket.h>
|
||||
#include <jni.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "jni_util.h"
|
||||
#include "jdk_net_SocketFlow.h"
|
||||
#include "SolarisSocketOptions.h"
|
||||
#include "jdk_net_SolarisSocketOptions.h"
|
||||
|
||||
#ifndef SO_FLOW_SLA
|
||||
#define SO_FLOW_SLA 0x1018
|
||||
|
||||
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
|
||||
#pragma pack(4)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Used with the setsockopt(SO_FLOW_SLA, ...) call to set
|
||||
* per socket service level properties.
|
||||
* When the application uses per-socket API, we will enforce the properties
|
||||
* on both outbound and inbound packets.
|
||||
*
|
||||
* For now, only priority and maxbw are supported in SOCK_FLOW_PROP_VERSION1.
|
||||
*/
|
||||
typedef struct sock_flow_props_s {
|
||||
int sfp_version;
|
||||
uint32_t sfp_mask;
|
||||
int sfp_priority; /* flow priority */
|
||||
uint64_t sfp_maxbw; /* bandwidth limit in bps */
|
||||
int sfp_status; /* flow create status for getsockopt */
|
||||
} sock_flow_props_t;
|
||||
|
||||
#define SOCK_FLOW_PROP_VERSION1 1
|
||||
|
||||
/* bit mask values for sfp_mask */
|
||||
#define SFP_MAXBW 0x00000001 /* Flow Bandwidth Limit */
|
||||
#define SFP_PRIORITY 0x00000008 /* Flow priority */
|
||||
|
||||
/* possible values for sfp_priority */
|
||||
#define SFP_PRIO_NORMAL 1
|
||||
#define SFP_PRIO_HIGH 2
|
||||
|
||||
#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
|
||||
#pragma pack()
|
||||
#endif /* _LONG_LONG_ALIGNMENT */
|
||||
|
||||
#endif /* SO_FLOW_SLA */
|
||||
|
||||
#endif /* SOLARIS_SOCKET_OPTIONS_H */
|
@ -28,6 +28,7 @@ module jdk.policytool {
|
||||
requires java.logging;
|
||||
requires java.management;
|
||||
requires java.sql;
|
||||
requires jdk.net;
|
||||
requires java.security.jgss;
|
||||
requires jdk.security.jgss;
|
||||
}
|
||||
|
@ -46,6 +46,8 @@ import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.stream.Stream;
|
||||
import java.lang.reflect.Module;
|
||||
import java.security.AllPermission;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -70,6 +72,12 @@ public class CustomLoggerTest {
|
||||
return new AtomicBoolean(false);
|
||||
}
|
||||
};
|
||||
static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {
|
||||
@Override
|
||||
protected AtomicBoolean initialValue() {
|
||||
return new AtomicBoolean(false);
|
||||
}
|
||||
};
|
||||
|
||||
public static class MyBundle extends ResourceBundle {
|
||||
|
||||
@ -241,7 +249,7 @@ public class CustomLoggerTest {
|
||||
}
|
||||
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
// We should check the permission to obey the API contract, but
|
||||
// what happens if we don't?
|
||||
// This is the main difference compared with what we test in
|
||||
@ -251,8 +259,13 @@ public class CustomLoggerTest {
|
||||
sm.checkPermission(SimplePolicy.LOGGERFINDER_PERMISSION);
|
||||
}
|
||||
|
||||
PrivilegedAction<ClassLoader> pa = () -> caller.getClassLoader();
|
||||
ClassLoader callerLoader = AccessController.doPrivileged(pa);
|
||||
final boolean before = allowAll.get().getAndSet(true);
|
||||
final ClassLoader callerLoader;
|
||||
try {
|
||||
callerLoader = caller.getClassLoader();
|
||||
} finally {
|
||||
allowAll.get().set(before);
|
||||
}
|
||||
if (callerLoader == null) {
|
||||
return system.computeIfAbsent(name, (n) -> new LoggerImpl(n));
|
||||
} else {
|
||||
@ -267,7 +280,7 @@ public class CustomLoggerTest {
|
||||
|
||||
static void setSecurityManager() {
|
||||
if (System.getSecurityManager() == null) {
|
||||
Policy.setPolicy(new SimplePolicy(allowControl));
|
||||
Policy.setPolicy(new SimplePolicy(allowControl, allowAll));
|
||||
System.setSecurityManager(new SecurityManager());
|
||||
}
|
||||
}
|
||||
@ -284,9 +297,9 @@ public class CustomLoggerTest {
|
||||
BaseLoggerFinder provider =
|
||||
BaseLoggerFinder.class.cast(LoggerFinder.getLoggerFinder());
|
||||
BaseLoggerFinder.LoggerImpl appSink =
|
||||
BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", CustomLoggerTest.class));
|
||||
BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", CustomLoggerTest.class.getModule()));
|
||||
BaseLoggerFinder.LoggerImpl sysSink =
|
||||
BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class));
|
||||
BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule()));
|
||||
|
||||
|
||||
Stream.of(args).map(TestCases::valueOf).forEach((testCase) -> {
|
||||
@ -695,34 +708,46 @@ public class CustomLoggerTest {
|
||||
static final RuntimePermission LOGGERFINDER_PERMISSION =
|
||||
new RuntimePermission("loggerFinder");
|
||||
final Permissions permissions;
|
||||
final Permissions controlPermissions;
|
||||
final Permissions allPermissions;
|
||||
final ThreadLocal<AtomicBoolean> allowControl;
|
||||
public SimplePolicy(ThreadLocal<AtomicBoolean> allowControl) {
|
||||
final ThreadLocal<AtomicBoolean> allowAll;
|
||||
public SimplePolicy(ThreadLocal<AtomicBoolean> allowControl, ThreadLocal<AtomicBoolean> allowAll) {
|
||||
this.allowControl = allowControl;
|
||||
this.allowAll = allowAll;
|
||||
permissions = new Permissions();
|
||||
|
||||
// these are used for configuring the test itself...
|
||||
controlPermissions = new Permissions();
|
||||
controlPermissions.add(LOGGERFINDER_PERMISSION);
|
||||
|
||||
// these are used for simulating a doPrivileged call from
|
||||
// a class in the BCL
|
||||
allPermissions = new Permissions();
|
||||
allPermissions.add(LOGGERFINDER_PERMISSION);
|
||||
allPermissions.add(new AllPermission());
|
||||
|
||||
}
|
||||
|
||||
Permissions permissions() {
|
||||
if (allowAll.get().get()) return allPermissions;
|
||||
if (allowControl.get().get()) return controlPermissions;
|
||||
return permissions;
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean implies(ProtectionDomain domain, Permission permission) {
|
||||
if (allowControl.get().get()) return allPermissions.implies(permission);
|
||||
return permissions.implies(permission);
|
||||
return permissions().implies(permission);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PermissionCollection getPermissions(CodeSource codesource) {
|
||||
return new PermissionsBuilder().addAll(allowControl.get().get()
|
||||
? allPermissions : permissions).toPermissions();
|
||||
return new PermissionsBuilder().addAll(permissions()).toPermissions();
|
||||
}
|
||||
|
||||
@Override
|
||||
public PermissionCollection getPermissions(ProtectionDomain domain) {
|
||||
return new PermissionsBuilder().addAll(allowControl.get().get()
|
||||
? allPermissions : permissions).toPermissions();
|
||||
return new PermissionsBuilder().addAll(permissions()).toPermissions();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -25,13 +25,14 @@ import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
public class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder {
|
||||
|
||||
static final RuntimePermission LOGGERFINDER_PERMISSION =
|
||||
new RuntimePermission("loggerFinder");
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
|
@ -182,8 +182,8 @@ public class BaseLoggerFinderTest {
|
||||
TestLoggerFinder.LoggerImpl appLogger1 = null;
|
||||
try {
|
||||
appLogger1 =
|
||||
TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class));
|
||||
loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class)");
|
||||
TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class.getModule()));
|
||||
loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a logger without permission");
|
||||
}
|
||||
@ -199,8 +199,8 @@ public class BaseLoggerFinderTest {
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
appLogger1 =
|
||||
TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class));
|
||||
loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class)");
|
||||
TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class.getModule()));
|
||||
loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -208,8 +208,8 @@ public class BaseLoggerFinderTest {
|
||||
|
||||
TestLoggerFinder.LoggerImpl sysLogger1 = null;
|
||||
try {
|
||||
sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class));
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class)");
|
||||
sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule()));
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -224,8 +224,8 @@ public class BaseLoggerFinderTest {
|
||||
final boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class));
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class)");
|
||||
sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule()));
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -254,8 +254,8 @@ public class BaseLoggerFinderTest {
|
||||
// callers and non system callers
|
||||
Logger appLogger2 = null;
|
||||
try {
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class);
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class)");
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class.getModule());
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a logger without permission");
|
||||
}
|
||||
@ -270,8 +270,8 @@ public class BaseLoggerFinderTest {
|
||||
final boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class);
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class)");
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class.getModule());
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -279,8 +279,8 @@ public class BaseLoggerFinderTest {
|
||||
|
||||
Logger sysLogger2 = null;
|
||||
try {
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class)");
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -295,8 +295,8 @@ public class BaseLoggerFinderTest {
|
||||
final boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class))");
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule()))");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
|
@ -30,6 +30,7 @@ import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
import java.util.function.Supplier;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* What our test provider needs to implement.
|
||||
@ -176,6 +177,6 @@ public interface TestLoggerFinder {
|
||||
}
|
||||
}
|
||||
|
||||
public Logger getLogger(String name, Class<?> caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class<?> caller);
|
||||
public Logger getLogger(String name, Module caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller);
|
||||
}
|
||||
|
@ -364,8 +364,8 @@ public class DefaultLoggerFinderTest {
|
||||
|
||||
Logger appLogger1 = null;
|
||||
try {
|
||||
appLogger1 = provider.getLogger("foo", DefaultLoggerFinderTest.class);
|
||||
loggerDescMap.put(appLogger1, "provider.getApplicationLogger(\"foo\")");
|
||||
appLogger1 = provider.getLogger("foo", DefaultLoggerFinderTest.class.getModule());
|
||||
loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", DefaultLoggerFinderTest.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a logger without permission");
|
||||
}
|
||||
@ -380,8 +380,8 @@ public class DefaultLoggerFinderTest {
|
||||
boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
appLogger1 =provider.getLogger("foo", DefaultLoggerFinderTest.class);
|
||||
loggerDescMap.put(appLogger1, "provider.getApplicationLogger(\"foo\")");
|
||||
appLogger1 =provider.getLogger("foo", DefaultLoggerFinderTest.class.getModule());
|
||||
loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", DefaultLoggerFinderTest.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -389,8 +389,8 @@ public class DefaultLoggerFinderTest {
|
||||
|
||||
Logger sysLogger1 = null;
|
||||
try {
|
||||
sysLogger1 = provider.getLogger("foo", Thread.class);
|
||||
loggerDescMap.put(sysLogger1, "provider.getSystemLogger(\"foo\")");
|
||||
sysLogger1 = provider.getLogger("foo", Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -405,8 +405,8 @@ public class DefaultLoggerFinderTest {
|
||||
boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
sysLogger1 = provider.getLogger("foo", Thread.class);
|
||||
loggerDescMap.put(sysLogger1, "provider.getSystemLogger(\"foo\")");
|
||||
sysLogger1 = provider.getLogger("foo", Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -417,8 +417,8 @@ public class DefaultLoggerFinderTest {
|
||||
|
||||
Logger appLogger2 = null;
|
||||
try {
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class);
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedApplicationLogger(\"foo\", loggerBundle)");
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class.getModule());
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, DefaultLoggerFinderTest.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a logger without permission");
|
||||
}
|
||||
@ -433,8 +433,8 @@ public class DefaultLoggerFinderTest {
|
||||
boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class);
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedApplicationLogger(\"foo\", loggerBundle)");
|
||||
appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class.getModule());
|
||||
loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, DefaultLoggerFinderTest.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -442,8 +442,8 @@ public class DefaultLoggerFinderTest {
|
||||
|
||||
Logger sysLogger2 = null;
|
||||
try {
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedSystemLogger(\"foo\", loggerBundle)");
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -458,8 +458,8 @@ public class DefaultLoggerFinderTest {
|
||||
boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedSystemLogger(\"foo\", loggerBundle)");
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())");
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
|
@ -55,6 +55,7 @@ import java.util.function.Function;
|
||||
import jdk.internal.logger.DefaultLoggerFinder;
|
||||
import jdk.internal.logger.SimpleConsoleLogger;
|
||||
import sun.util.logging.PlatformLogger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -112,10 +113,10 @@ public class BaseDefaultLoggerFinderTest {
|
||||
public final static AtomicLong sequencer = new AtomicLong();
|
||||
|
||||
|
||||
public Logger getLogger(String name, Class<?> caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class<?> caller);
|
||||
void setLevel(Logger logger, Level level, Class<?> caller);
|
||||
void setLevel(Logger logger, PlatformLogger.Level level, Class<?> caller);
|
||||
public Logger getLogger(String name, Module caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller);
|
||||
void setLevel(Logger logger, Level level, Module caller);
|
||||
void setLevel(Logger logger, PlatformLogger.Level level, Module caller);
|
||||
PlatformLogger.Bridge asPlatformLoggerBridge(Logger logger);
|
||||
}
|
||||
|
||||
@ -130,7 +131,7 @@ public class BaseDefaultLoggerFinderTest {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLevel(Logger logger, Level level, Class<?> caller) {
|
||||
public void setLevel(Logger logger, Level level, Module caller) {
|
||||
PrivilegedAction<Void> pa = () -> {
|
||||
setLevel(logger, PlatformLogger.toPlatformLevel(level), caller);
|
||||
return null;
|
||||
@ -139,7 +140,7 @@ public class BaseDefaultLoggerFinderTest {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLevel(Logger logger, PlatformLogger.Level level, Class<?> caller) {
|
||||
public void setLevel(Logger logger, PlatformLogger.Level level, Module caller) {
|
||||
PrivilegedAction<Logger> pa = () -> demandLoggerFor(logger.getName(), caller);
|
||||
Logger impl = AccessController.doPrivileged(pa);
|
||||
SimpleConsoleLogger.class.cast(impl)
|
||||
@ -606,11 +607,12 @@ public class BaseDefaultLoggerFinderTest {
|
||||
String name,
|
||||
ResourceBundle loggerBundle,
|
||||
Logger logger,
|
||||
Class<?> caller) {
|
||||
Class<?> callerClass) {
|
||||
|
||||
System.out.println("Testing " + loggerDescMap.get(logger) + " [" + logger +"]");
|
||||
AtomicLong sequencer = TestLoggerFinder.sequencer;
|
||||
|
||||
Module caller = callerClass.getModule();
|
||||
Foo foo = new Foo();
|
||||
String fooMsg = foo.toString();
|
||||
for (Level loggerLevel : Level.values()) {
|
||||
|
@ -47,6 +47,7 @@ import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.stream.Stream;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -209,8 +210,6 @@ public class BaseLoggerBridgeTest {
|
||||
return Arrays.deepToString(toArray(false));
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
return obj instanceof LogEvent
|
||||
@ -342,15 +341,15 @@ public class BaseLoggerBridgeTest {
|
||||
|
||||
}
|
||||
|
||||
public Logger getLogger(String name, Class<?> caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class<?> caller);
|
||||
public Logger getLogger(String name, Module caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller);
|
||||
}
|
||||
|
||||
public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder {
|
||||
static final RuntimePermission LOGGERFINDER_PERMISSION =
|
||||
new RuntimePermission("loggerFinder");
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
@ -375,7 +374,7 @@ public class BaseLoggerBridgeTest {
|
||||
}
|
||||
}
|
||||
|
||||
static Logger getLogger(String name, Class<?> caller) {
|
||||
static Logger getLogger(String name, Module caller) {
|
||||
boolean old = allowAll.get().get();
|
||||
allowAccess.get().set(true);
|
||||
try {
|
||||
@ -465,7 +464,7 @@ public class BaseLoggerBridgeTest {
|
||||
|
||||
TestLoggerFinder.LoggerImpl appSink = null;
|
||||
try {
|
||||
appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class));
|
||||
appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class.getModule()));
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -480,7 +479,7 @@ public class BaseLoggerBridgeTest {
|
||||
boolean old = allowControl.get().get();
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class));
|
||||
appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class.getModule()));
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
@ -489,7 +488,7 @@ public class BaseLoggerBridgeTest {
|
||||
|
||||
TestLoggerFinder.LoggerImpl sysSink = null;
|
||||
try {
|
||||
sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class));
|
||||
sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule()));
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -527,13 +526,13 @@ public class BaseLoggerBridgeTest {
|
||||
|
||||
Logger sysLogger1 = null;
|
||||
try {
|
||||
sysLogger1 = getLogger("foo", Thread.class);
|
||||
sysLogger1 = getLogger("foo", Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger1,
|
||||
"jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class)");
|
||||
"jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class.getModule())");
|
||||
|
||||
if (!hasRequiredPermissions) {
|
||||
// check that the provider would have thrown an exception
|
||||
provider.getLogger("foo", Thread.class);
|
||||
provider.getLogger("foo", Thread.class.getModule());
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
} catch (AccessControlException acx) {
|
||||
@ -572,8 +571,8 @@ public class BaseLoggerBridgeTest {
|
||||
|
||||
Logger sysLogger2 = null;
|
||||
try {
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class)");
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
|
@ -47,6 +47,7 @@ import java.lang.System.Logger.Level;
|
||||
import java.security.AccessControlException;
|
||||
import java.util.stream.Stream;
|
||||
import sun.util.logging.PlatformLogger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -327,12 +328,12 @@ public class BasePlatformLoggerTest {
|
||||
}
|
||||
}
|
||||
|
||||
public Logger getLogger(String name, Class<?> caller);
|
||||
public Logger getLogger(String name, Module caller);
|
||||
}
|
||||
|
||||
public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder {
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
@ -433,7 +434,7 @@ public class BasePlatformLoggerTest {
|
||||
try {
|
||||
allowControl.get().set(true);
|
||||
appSink = TestLoggerFinder.LoggerImpl.class.cast(
|
||||
provider.getLogger("foo", BasePlatformLoggerTest.class));
|
||||
provider.getLogger("foo", BasePlatformLoggerTest.class.getModule()));
|
||||
} finally {
|
||||
allowControl.get().set(before);
|
||||
}
|
||||
@ -442,7 +443,8 @@ public class BasePlatformLoggerTest {
|
||||
before = allowControl.get().get();
|
||||
try {
|
||||
allowControl.get().set(true);
|
||||
sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class));
|
||||
sysSink = TestLoggerFinder.LoggerImpl.class.cast(
|
||||
provider.getLogger("foo", Thread.class.getModule()));
|
||||
} finally {
|
||||
allowControl.get().set(before);
|
||||
}
|
||||
|
@ -30,7 +30,7 @@ import java.util.Enumeration;
|
||||
import java.util.List;
|
||||
import java.util.ResourceBundle;
|
||||
import java.util.Set;
|
||||
|
||||
import java.lang.reflect.Module;
|
||||
import jdk.internal.logger.BootstrapLogger;
|
||||
import jdk.internal.logger.LazyLoggers;
|
||||
|
||||
@ -69,7 +69,7 @@ public class BootstrapLoggerAPIsTest {
|
||||
}
|
||||
|
||||
final Logger LOGGER =
|
||||
LazyLoggers.getLogger("foo.bar", Thread.class);
|
||||
LazyLoggers.getLogger("foo.bar", Thread.class.getModule());
|
||||
final sun.util.logging.PlatformLogger.Level PLATFORM_LEVEL =
|
||||
sun.util.logging.PlatformLogger.Level.SEVERE;
|
||||
final MyResources BUNDLE = new MyResources();
|
||||
|
@ -43,6 +43,7 @@ import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
import jdk.internal.logger.BootstrapLogger;
|
||||
import jdk.internal.logger.LazyLoggers;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/*
|
||||
* @test
|
||||
@ -105,7 +106,7 @@ public class BootstrapLoggerTest {
|
||||
if (BootstrapLogger.isBooted()) {
|
||||
throw new RuntimeException("VM should not be booted!");
|
||||
}
|
||||
Logger logger = LazyLoggers.getLogger("foo.bar", Thread.class);
|
||||
Logger logger = LazyLoggers.getLogger("foo.bar", Thread.class.getModule());
|
||||
|
||||
if (test != TestCase.NO_SECURITY) {
|
||||
LogStream.err.println("Setting security manager");
|
||||
@ -261,7 +262,7 @@ public class BootstrapLoggerTest {
|
||||
SimplePolicy.allowAll.set(Boolean.TRUE);
|
||||
try {
|
||||
bazbaz = java.lang.System.LoggerFinder
|
||||
.getLoggerFinder().getLogger("foo.bar.baz.baz", BootstrapLoggerTest.class);
|
||||
.getLoggerFinder().getLogger("foo.bar.baz.baz", BootstrapLoggerTest.class.getModule());
|
||||
} finally {
|
||||
SimplePolicy.allowAll.set(Boolean.FALSE);
|
||||
}
|
||||
|
@ -51,6 +51,7 @@ import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.stream.Stream;
|
||||
import sun.util.logging.PlatformLogger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -164,6 +165,7 @@ public class LoggerBridgeTest {
|
||||
null, null, level, bundle, key,
|
||||
thrown, params);
|
||||
}
|
||||
|
||||
public static LogEvent of(long sequenceNumber,
|
||||
boolean isLoggable, String name,
|
||||
sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,
|
||||
@ -231,7 +233,7 @@ public class LoggerBridgeTest {
|
||||
try {
|
||||
// Preload classes before the security manager is on.
|
||||
providerClass = ClassLoader.getSystemClassLoader().loadClass("LoggerBridgeTest$LogProducerFinder");
|
||||
((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass);
|
||||
((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass.getModule());
|
||||
} catch (Exception ex) {
|
||||
throw new ExceptionInInitializerError(ex);
|
||||
}
|
||||
@ -415,7 +417,7 @@ public class LoggerBridgeTest {
|
||||
}
|
||||
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
@ -430,6 +432,15 @@ public class LoggerBridgeTest {
|
||||
}
|
||||
}
|
||||
|
||||
static ClassLoader getClassLoader(Module m) {
|
||||
final boolean before = allowAll.get().getAndSet(true);
|
||||
try {
|
||||
return m.getClassLoader();
|
||||
} finally {
|
||||
allowAll.get().set(before);
|
||||
}
|
||||
}
|
||||
|
||||
static final sun.util.logging.PlatformLogger.Level[] julLevels = {
|
||||
sun.util.logging.PlatformLogger.Level.ALL,
|
||||
sun.util.logging.PlatformLogger.Level.FINEST,
|
||||
@ -497,14 +508,14 @@ public class LoggerBridgeTest {
|
||||
try {
|
||||
Class<?> bridgeClass = Class.forName("jdk.internal.logger.LazyLoggers");
|
||||
lazyGetLogger = bridgeClass.getDeclaredMethod("getLogger",
|
||||
String.class, Class.class);
|
||||
String.class, Module.class);
|
||||
lazyGetLogger.setAccessible(true);
|
||||
} catch (Throwable ex) {
|
||||
throw new ExceptionInInitializerError(ex);
|
||||
}
|
||||
}
|
||||
|
||||
static Logger getLogger(LoggerFinder provider, String name, Class<?> caller) {
|
||||
static Logger getLogger(LoggerFinder provider, String name, Module caller) {
|
||||
Logger logger;
|
||||
try {
|
||||
logger = Logger.class.cast(lazyGetLogger.invoke(null, name, caller));
|
||||
@ -522,14 +533,14 @@ public class LoggerBridgeTest {
|
||||
// The method above does not throw exception...
|
||||
// call the provider here to verify that an exception would have
|
||||
// been thrown by the provider.
|
||||
if (logger != null && caller == Thread.class) {
|
||||
if (logger != null && caller == Thread.class.getModule()) {
|
||||
Logger log = provider.getLogger(name, caller);
|
||||
}
|
||||
return logger;
|
||||
}
|
||||
|
||||
static Logger getLogger(LoggerFinder provider, String name, ResourceBundle bundle, Class<?> caller) {
|
||||
if (caller.getClassLoader() != null) {
|
||||
static Logger getLogger(LoggerFinder provider, String name, ResourceBundle bundle, Module caller) {
|
||||
if (getClassLoader(caller) != null) {
|
||||
return System.getLogger(name,bundle);
|
||||
} else {
|
||||
return provider.getLocalizedLogger(name, bundle, caller);
|
||||
@ -614,12 +625,12 @@ public class LoggerBridgeTest {
|
||||
|
||||
|
||||
Logger appLogger1 = System.getLogger("foo");
|
||||
loggerDescMap.put(appLogger1, "LogProducer.getApplicationLogger(\"foo\")");
|
||||
loggerDescMap.put(appLogger1, "System.getLogger(\"foo\")");
|
||||
|
||||
Logger sysLogger1 = null;
|
||||
try {
|
||||
sysLogger1 = getLogger(provider, "foo", Thread.class);
|
||||
loggerDescMap.put(sysLogger1, "LogProducer.getSystemLogger(\"foo\")");
|
||||
sysLogger1 = getLogger(provider, "foo", Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -636,12 +647,12 @@ public class LoggerBridgeTest {
|
||||
|
||||
Logger appLogger2 =
|
||||
System.getLogger("foo", loggerBundle);
|
||||
loggerDescMap.put(appLogger2, "LogProducer.getApplicationLogger(\"foo\", loggerBundle)");
|
||||
loggerDescMap.put(appLogger2, "System.getLogger(\"foo\", loggerBundle)");
|
||||
|
||||
Logger sysLogger2 = null;
|
||||
try {
|
||||
sysLogger2 = getLogger(provider, "foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getSystemLogger(\"foo\", loggerBundle)");
|
||||
sysLogger2 = getLogger(provider, "foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLogger(\"foo\", loggerBundle, Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -671,9 +682,9 @@ public class LoggerBridgeTest {
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
appSink = LogProducerFinder.LoggerImpl.class.cast(
|
||||
provider.getLogger("foo", LoggerBridgeTest.class));
|
||||
provider.getLogger("foo", LoggerBridgeTest.class.getModule()));
|
||||
sysSink = LogProducerFinder.LoggerImpl.class.cast(
|
||||
provider.getLogger("foo", Thread.class));
|
||||
provider.getLogger("foo", Thread.class.getModule()));
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
|
@ -53,6 +53,7 @@ import java.util.ServiceConfigurationError;
|
||||
import java.util.ServiceLoader;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
import jdk.internal.logger.SimpleConsoleLogger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -166,8 +167,8 @@ public class LoggerFinderLoaderTest {
|
||||
|
||||
}
|
||||
|
||||
public Logger getLogger(String name, Class<?> caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class<?> caller);
|
||||
public Logger getLogger(String name, Module caller);
|
||||
public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller);
|
||||
}
|
||||
|
||||
public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder {
|
||||
@ -187,7 +188,7 @@ public class LoggerFinderLoaderTest {
|
||||
|
||||
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
@ -210,7 +211,7 @@ public class LoggerFinderLoaderTest {
|
||||
throw new ServiceConfigurationError("Should not come here");
|
||||
}
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
throw new ServiceConfigurationError("Should not come here");
|
||||
}
|
||||
}
|
||||
|
@ -49,6 +49,7 @@ import java.lang.System.Logger;
|
||||
import java.lang.System.Logger.Level;
|
||||
import java.util.stream.Stream;
|
||||
import sun.util.logging.PlatformLogger;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -94,7 +95,7 @@ public class PlatformLoggerBridgeTest {
|
||||
try {
|
||||
// Preload classes before the security manager is on.
|
||||
providerClass = ClassLoader.getSystemClassLoader().loadClass("PlatformLoggerBridgeTest$LogProducerFinder");
|
||||
((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass);
|
||||
((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass.getModule());
|
||||
} catch (Exception ex) {
|
||||
throw new ExceptionInInitializerError(ex);
|
||||
}
|
||||
@ -415,7 +416,7 @@ public class PlatformLoggerBridgeTest {
|
||||
}
|
||||
|
||||
@Override
|
||||
public Logger getLogger(String name, Class<?> caller) {
|
||||
public Logger getLogger(String name, Module caller) {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
sm.checkPermission(LOGGERFINDER_PERMISSION);
|
||||
@ -598,7 +599,7 @@ public class PlatformLoggerBridgeTest {
|
||||
allowControl.get().set(true);
|
||||
try {
|
||||
sysSink = LogProducerFinder.LoggerImpl.class.cast(
|
||||
provider.getLogger("foo", Thread.class));
|
||||
provider.getLogger("foo", Thread.class.getModule()));
|
||||
} finally {
|
||||
allowControl.get().set(old);
|
||||
}
|
||||
|
@ -469,12 +469,12 @@ public class LoggerFinderAPITest {
|
||||
errors.append(test.testGetLoggerOverriddenOnSpi());
|
||||
java.lang.System.Logger julLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLogger("foo", LoggerFinderAPITest.class);
|
||||
.getLogger("foo", LoggerFinderAPITest.class.getModule());
|
||||
errors.append(test.testDefaultJULLogger(julLogger));
|
||||
if (errors.length() > 0) throw new RuntimeException(errors.toString());
|
||||
java.lang.System.Logger julSystemLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLogger("bar", Thread.class);
|
||||
.getLogger("bar", Thread.class.getModule());
|
||||
errors.append(test.testDefaultJULLogger(julSystemLogger));
|
||||
if (errors.length() > 0) throw new RuntimeException(errors.toString());
|
||||
java.lang.System.Logger julLocalizedLogger =
|
||||
@ -482,7 +482,7 @@ public class LoggerFinderAPITest {
|
||||
System.getLogger("baz", bundleLocalized);
|
||||
java.lang.System.Logger julLocalizedSystemLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLocalizedLogger("oof", bundleLocalized, Thread.class);
|
||||
.getLocalizedLogger("oof", bundleLocalized, Thread.class.getModule());
|
||||
final String error = errors.toString();
|
||||
if (!error.isEmpty()) throw new RuntimeException(error);
|
||||
for (java.lang.System.Logger logger : new java.lang.System.Logger[] {
|
||||
|
@ -77,6 +77,7 @@ import java.util.logging.LogManager;
|
||||
import java.util.logging.LogRecord;
|
||||
import java.util.logging.Logger;
|
||||
import sun.util.logging.internal.LoggingProviderImpl;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @author danielfuchs
|
||||
@ -1506,7 +1507,7 @@ public class LoggerFinderBackendTest {
|
||||
Logger getBackendLogger(String name) {
|
||||
if (isSystem) {
|
||||
return LoggingProviderImpl.getLogManagerAccess().demandLoggerFor(
|
||||
LogManager.getLogManager(), name, Thread.class);
|
||||
LogManager.getLogManager(), name, Thread.class.getModule());
|
||||
} else {
|
||||
return Logger.getLogger(name);
|
||||
}
|
||||
@ -1699,7 +1700,7 @@ public class LoggerFinderBackendTest {
|
||||
Collections.synchronizedMap(new HashMap<>());
|
||||
|
||||
@Override
|
||||
public java.lang.System.Logger getLogger(String name, Class<?> caller) {
|
||||
public java.lang.System.Logger getLogger(String name, Module caller) {
|
||||
ClassLoader callerLoader = caller.getClassLoader();
|
||||
if (callerLoader == null) {
|
||||
systemLoggers.putIfAbsent(name, new CustomLogger(name));
|
||||
@ -1827,8 +1828,8 @@ public class LoggerFinderBackendTest {
|
||||
public void setLevel(java.lang.System.Logger logger, Level level) {
|
||||
final CustomLoggerFinder.CustomLogger l =
|
||||
(CustomLoggerFinder.CustomLogger)
|
||||
(isSystem ? provider.getLogger(logger.getName(), Thread.class) :
|
||||
provider.getLogger(logger.getName(), LoggerFinderBackendTest.class));
|
||||
(isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) :
|
||||
provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule()));
|
||||
l.setLevel(provider.fromJul(level));
|
||||
}
|
||||
@Override
|
||||
@ -1840,8 +1841,8 @@ public class LoggerFinderBackendTest {
|
||||
CustomLoggerFinder.CustomLevel getLevel(java.lang.System.Logger logger) {
|
||||
final CustomLoggerFinder.CustomLogger l =
|
||||
(CustomLoggerFinder.CustomLogger)
|
||||
(isSystem ? provider.getLogger(logger.getName(), Thread.class) :
|
||||
provider.getLogger(logger.getName(), LoggerFinderBackendTest.class));
|
||||
(isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) :
|
||||
provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule()));
|
||||
return l.level;
|
||||
}
|
||||
|
||||
@ -1962,7 +1963,7 @@ public class LoggerFinderBackendTest {
|
||||
try {
|
||||
Class<?> lazyLoggers = jdk.internal.logger.LazyLoggers.class;
|
||||
getLazyLogger = lazyLoggers.getMethod("getLazyLogger",
|
||||
String.class, Class.class);
|
||||
String.class, Module.class);
|
||||
getLazyLogger.setAccessible(true);
|
||||
Class<?> loggerFinderLoader =
|
||||
Class.forName("java.lang.System$LoggerFinder");
|
||||
@ -1973,7 +1974,7 @@ public class LoggerFinderBackendTest {
|
||||
}
|
||||
}
|
||||
|
||||
static java.lang.System.Logger getSystemLogger(String name, Class<?> caller) throws Exception {
|
||||
static java.lang.System.Logger getSystemLogger(String name, Module caller) throws Exception {
|
||||
try {
|
||||
return java.lang.System.Logger.class.cast(getLazyLogger.invoke(null, name, caller));
|
||||
} catch (InvocationTargetException x) {
|
||||
@ -1986,7 +1987,7 @@ public class LoggerFinderBackendTest {
|
||||
}
|
||||
}
|
||||
static java.lang.System.Logger getSystemLogger(String name,
|
||||
ResourceBundle bundle, Class<?> caller) throws Exception {
|
||||
ResourceBundle bundle, Module caller) throws Exception {
|
||||
try {
|
||||
LoggerFinder provider = LoggerFinder.class.cast(accessLoggerFinder.invoke(null));
|
||||
return provider.getLocalizedLogger(name, bundle, caller);
|
||||
@ -2047,14 +2048,14 @@ public class LoggerFinderBackendTest {
|
||||
final BackendTester tester = factory.createBackendTester(false);
|
||||
final java.lang.System.Logger logger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLogger("foo", LoggerFinderBackendTest.class);
|
||||
.getLogger("foo", LoggerFinderBackendTest.class.getModule());
|
||||
|
||||
testLogger(tester, logger, nb);
|
||||
|
||||
// Test a simple system logger with JUL backend
|
||||
final java.lang.System.Logger system =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLogger("bar", Thread.class);
|
||||
.getLogger("bar", Thread.class.getModule());
|
||||
final BackendTester systemTester = factory.createBackendTester(true);
|
||||
testLogger(systemTester, system, nb);
|
||||
|
||||
@ -2062,7 +2063,7 @@ public class LoggerFinderBackendTest {
|
||||
// JUL backend
|
||||
final java.lang.System.Logger noBundleLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLocalizedLogger("baz", null, LoggerFinderBackendTest.class);
|
||||
.getLocalizedLogger("baz", null, LoggerFinderBackendTest.class.getModule());
|
||||
final BackendTester noBundleTester =
|
||||
factory.createBackendTester(false, spiLoggerClass);
|
||||
testLogger(noBundleTester, noBundleLogger, nb);
|
||||
@ -2071,7 +2072,7 @@ public class LoggerFinderBackendTest {
|
||||
// backend
|
||||
final java.lang.System.Logger noBundleSysLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLocalizedLogger("oof", null, Thread.class);
|
||||
.getLocalizedLogger("oof", null, Thread.class.getModule());
|
||||
final BackendTester noBundleSysTester =
|
||||
factory.createBackendTester(true, spiLoggerClass);
|
||||
testLogger(noBundleSysTester, noBundleSysLogger, nb);
|
||||
@ -2085,14 +2086,14 @@ public class LoggerFinderBackendTest {
|
||||
System.out.println("System.Loggers.getLogger(\"baz\", null): got expected " + x);
|
||||
}
|
||||
final java.lang.System.Logger noBundleExtensionLogger =
|
||||
getSystemLogger("baz", null, LoggerFinderBackendTest.class);
|
||||
getSystemLogger("baz", null, LoggerFinderBackendTest.class.getModule());
|
||||
final BackendTester noBundleExtensionTester =
|
||||
factory.createBackendTester(false, jdkLoggerClass);
|
||||
testLogger(noBundleExtensionTester, noBundleExtensionLogger, nb);
|
||||
|
||||
// Test a simple system logger with JUL backend
|
||||
final java.lang.System.Logger sysExtensionLogger =
|
||||
getSystemLogger("oof", Thread.class);
|
||||
getSystemLogger("oof", Thread.class.getModule());
|
||||
final BackendTester sysExtensionTester =
|
||||
factory.createBackendTester(true, jdkLoggerClass);
|
||||
testLogger(sysExtensionTester, sysExtensionLogger, nb);
|
||||
@ -2100,7 +2101,7 @@ public class LoggerFinderBackendTest {
|
||||
// Test a localized system logger with null resource bundle and JUL
|
||||
// backend
|
||||
final java.lang.System.Logger noBundleSysExtensionLogger =
|
||||
getSystemLogger("oof", null, Thread.class);
|
||||
getSystemLogger("oof", null, Thread.class.getModule());
|
||||
final BackendTester noBundleSysExtensionTester =
|
||||
factory.createBackendTester(true, jdkLoggerClass);
|
||||
testLogger(noBundleSysExtensionTester, noBundleSysExtensionLogger, nb);
|
||||
@ -2127,7 +2128,7 @@ public class LoggerFinderBackendTest {
|
||||
ResourceBundle.getBundle(ResourceBundeLocalized.class.getName());
|
||||
final java.lang.System.Logger bundleLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class);
|
||||
.getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class.getModule());
|
||||
final BackendTester bundleTester =
|
||||
factory.createBackendTester(false, spiLoggerClass, bundle);
|
||||
testLogger(bundleTester, bundleLogger, nb);
|
||||
@ -2135,7 +2136,7 @@ public class LoggerFinderBackendTest {
|
||||
// Test a localized system logger with resource bundle and JUL backend
|
||||
final java.lang.System.Logger bundleSysLogger =
|
||||
java.lang.System.LoggerFinder.getLoggerFinder()
|
||||
.getLocalizedLogger("titi", bundle, Thread.class);
|
||||
.getLocalizedLogger("titi", bundle, Thread.class.getModule());
|
||||
final BackendTester bundleSysTester =
|
||||
factory.createBackendTester(true, spiLoggerClass, bundle);
|
||||
testLogger(bundleSysTester, bundleSysLogger, nb);
|
||||
@ -2151,7 +2152,7 @@ public class LoggerFinderBackendTest {
|
||||
// Test a localized Jdk system logger with resource bundle and JUL
|
||||
// backend
|
||||
final java.lang.System.Logger bundleExtensionSysLogger =
|
||||
getSystemLogger("titu", bundle, Thread.class);
|
||||
getSystemLogger("titu", bundle, Thread.class.getModule());
|
||||
final BackendTester bundleExtensionSysTester =
|
||||
factory.createBackendTester(true, jdkLoggerClass, bundle);
|
||||
testLogger(bundleExtensionSysTester, bundleExtensionSysLogger, nb);
|
||||
|
@ -48,6 +48,7 @@ import java.lang.System.LoggerFinder;
|
||||
import java.lang.System.Logger;
|
||||
import java.util.stream.Stream;
|
||||
import sun.util.logging.internal.LoggingProviderImpl;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -246,7 +247,7 @@ public class DefaultLoggerBridgeTest {
|
||||
}
|
||||
}
|
||||
|
||||
static Logger getLogger(String name, Class<?> caller) {
|
||||
static Logger getLogger(String name, Module caller) {
|
||||
boolean old = allowAccess.get().get();
|
||||
allowAccess.get().set(true);
|
||||
try {
|
||||
@ -311,8 +312,8 @@ public class DefaultLoggerBridgeTest {
|
||||
ResourceBundle.getBundle(MyLoggerBundle.class.getName());
|
||||
final Map<Object, String> loggerDescMap = new HashMap<>();
|
||||
|
||||
Logger sysLogger1a = getLogger("foo", Thread.class);
|
||||
loggerDescMap.put(sysLogger1a, "jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class)");
|
||||
Logger sysLogger1a = getLogger("foo", Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger1a, "jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class.getModule())");
|
||||
|
||||
Logger appLogger1 = System.getLogger("foo");
|
||||
loggerDescMap.put(appLogger1, "System.getLogger(\"foo\")");
|
||||
@ -341,9 +342,9 @@ public class DefaultLoggerBridgeTest {
|
||||
|
||||
Logger sysLogger1b = null;
|
||||
try {
|
||||
sysLogger1b = provider.getLogger("foo", Thread.class);
|
||||
sysLogger1b = provider.getLogger("foo", Thread.class.getModule());
|
||||
if (sysLogger1b != sysLogger1a) {
|
||||
loggerDescMap.put(sysLogger1b, "provider.getLogger(\"foo\", Thread.class)");
|
||||
loggerDescMap.put(sysLogger1b, "provider.getLogger(\"foo\", Thread.class.getModule())");
|
||||
}
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
@ -367,8 +368,8 @@ public class DefaultLoggerBridgeTest {
|
||||
|
||||
Logger sysLogger2 = null;
|
||||
try {
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class);
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class)");
|
||||
sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule());
|
||||
loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())");
|
||||
if (!hasRequiredPermissions) {
|
||||
throw new RuntimeException("Managed to obtain a system logger without permission");
|
||||
}
|
||||
@ -396,9 +397,9 @@ public class DefaultLoggerBridgeTest {
|
||||
allowAll.get().set(true);
|
||||
try {
|
||||
sysSink = LoggingProviderImpl.getLogManagerAccess().demandLoggerFor(
|
||||
LogManager.getLogManager(), "foo", Thread.class);
|
||||
LogManager.getLogManager(), "foo", Thread.class.getModule());
|
||||
appSink = LoggingProviderImpl.getLogManagerAccess().demandLoggerFor(
|
||||
LogManager.getLogManager(), "foo", DefaultLoggerBridgeTest.class);
|
||||
LogManager.getLogManager(), "foo", DefaultLoggerBridgeTest.class.getModule());
|
||||
if (appSink == sysSink) {
|
||||
throw new RuntimeException("identical backend loggers");
|
||||
}
|
||||
|
@ -44,6 +44,7 @@ import java.util.logging.LogRecord;
|
||||
import java.lang.System.LoggerFinder;
|
||||
import sun.util.logging.PlatformLogger;
|
||||
import sun.util.logging.internal.LoggingProviderImpl;
|
||||
import java.lang.reflect.Module;
|
||||
|
||||
/**
|
||||
* @test
|
||||
@ -244,9 +245,9 @@ public class DefaultPlatformLoggerTest {
|
||||
LoggerFinder provider = LoggerFinder.getLoggerFinder();
|
||||
java.util.logging.Logger appSink = LoggingProviderImpl.getLogManagerAccess()
|
||||
.demandLoggerFor(LogManager.getLogManager(), "foo",
|
||||
DefaultPlatformLoggerTest.class);
|
||||
DefaultPlatformLoggerTest.class.getModule());
|
||||
java.util.logging.Logger sysSink = LoggingProviderImpl.getLogManagerAccess()
|
||||
.demandLoggerFor(LogManager.getLogManager(),"foo", Thread.class);
|
||||
.demandLoggerFor(LogManager.getLogManager(),"foo", Thread.class.getModule());
|
||||
appSink.addHandler(new MyHandler());
|
||||
sysSink.addHandler(new MyHandler());
|
||||
appSink.setUseParentHandlers(VERBOSE);
|
||||
|
91
jdk/test/java/lang/invoke/ArrayConstructorTest.java
Normal file
91
jdk/test/java/lang/invoke/ArrayConstructorTest.java
Normal file
@ -0,0 +1,91 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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 8155106
|
||||
* @run testng/othervm -ea -esa test.java.lang.invoke.ArrayConstructorTest
|
||||
*/
|
||||
package test.java.lang.invoke;
|
||||
|
||||
import java.lang.invoke.MethodHandle;
|
||||
import java.lang.invoke.MethodHandles;
|
||||
|
||||
import static java.lang.invoke.MethodType.methodType;
|
||||
|
||||
import static org.testng.AssertJUnit.*;
|
||||
|
||||
import org.testng.annotations.*;
|
||||
|
||||
|
||||
public class ArrayConstructorTest {
|
||||
|
||||
static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
|
||||
|
||||
@Test
|
||||
public static void testFindConstructorArray() {
|
||||
boolean caught = false;
|
||||
try {
|
||||
MethodHandle h = LOOKUP.findConstructor(Object[].class, methodType(void.class));
|
||||
} catch (NoSuchMethodException nsme) {
|
||||
assertEquals("no constructor for array class: [Ljava.lang.Object;", nsme.getMessage());
|
||||
caught = true;
|
||||
} catch (Exception e) {
|
||||
throw new AssertionError("unexpected exception: " + e);
|
||||
}
|
||||
assertTrue(caught);
|
||||
}
|
||||
|
||||
@DataProvider
|
||||
static Object[][] arrayConstructorNegative() {
|
||||
return new Object[][]{
|
||||
{String.class, IllegalArgumentException.class, "not an array class: java.lang.String"},
|
||||
{null, NullPointerException.class, null}
|
||||
};
|
||||
}
|
||||
|
||||
@Test(dataProvider = "arrayConstructorNegative")
|
||||
public static void testArrayConstructorNegative(Class<?> clazz, Class<?> exceptionClass, String message) {
|
||||
boolean caught = false;
|
||||
try {
|
||||
MethodHandle h = MethodHandles.arrayConstructor(clazz);
|
||||
} catch (Exception e) {
|
||||
assertEquals(exceptionClass, e.getClass());
|
||||
if (message != null) {
|
||||
assertEquals(message, e.getMessage());
|
||||
}
|
||||
caught = true;
|
||||
}
|
||||
assertTrue(caught);
|
||||
}
|
||||
|
||||
@Test
|
||||
public static void testArrayConstructor() throws Throwable {
|
||||
MethodHandle h = MethodHandles.arrayConstructor(String[].class);
|
||||
assertEquals(methodType(String[].class, int.class), h.type());
|
||||
String[] a = (String[]) h.invoke(17);
|
||||
assertEquals(17, a.length);
|
||||
}
|
||||
|
||||
}
|
46
jdk/test/java/lang/invoke/JavaUtilConcurrentLookupTest.java
Normal file
46
jdk/test/java/lang/invoke/JavaUtilConcurrentLookupTest.java
Normal file
@ -0,0 +1,46 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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
|
||||
* @summary Tests that Lookup can be produced from classes under java.util.concurrent
|
||||
* @bug 8154447
|
||||
* @compile/module=java.base java/util/concurrent/LookupTester.java
|
||||
* @run testng/othervm JavaUtilConcurrentLookupTest
|
||||
*/
|
||||
|
||||
import org.testng.annotations.Test;
|
||||
|
||||
import java.util.concurrent.LookupTester;
|
||||
|
||||
public class JavaUtilConcurrentLookupTest {
|
||||
|
||||
@Test
|
||||
public void testLookup() {
|
||||
LookupTester.getLookup();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLookupIn() {
|
||||
LookupTester.getLookupIn();
|
||||
}
|
||||
}
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2011, 2016, 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
|
||||
@ -23,6 +23,7 @@
|
||||
|
||||
/* @test
|
||||
* @summary unit tests for method handles which permute their arguments
|
||||
* @library /lib/testlibrary/jsr292 /lib/testlibrary
|
||||
* @run testng/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest
|
||||
*/
|
||||
/* Examples of manual runs:
|
||||
@ -36,6 +37,8 @@ package test.java.lang.invoke;
|
||||
import org.testng.*;
|
||||
import org.testng.annotations.*;
|
||||
|
||||
import com.oracle.testlibrary.jsr292.CodeCacheOverflowProcessor;
|
||||
|
||||
import java.util.*;
|
||||
import java.lang.reflect.*;
|
||||
|
||||
@ -122,9 +125,15 @@ public class PermuteArgsTest {
|
||||
}
|
||||
new PermuteArgsTest().test();
|
||||
}
|
||||
|
||||
static int testCases;
|
||||
|
||||
@Test
|
||||
public void test() throws Throwable {
|
||||
CodeCacheOverflowProcessor.runMHTest(this::test0);
|
||||
}
|
||||
|
||||
public void test0() throws Throwable {
|
||||
testCases = 0;
|
||||
Lookup lookup = lookup();
|
||||
for (Method m : lookup.lookupClass().getDeclaredMethods()) {
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessBoolean extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessByte extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessChar extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessDouble extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessFloat extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessInt extends VarHandleBaseTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessLong extends VarHandleBaseTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessShort extends VarHandleBaseTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -106,7 +106,6 @@ public class VarHandleTestAccessString extends VarHandleBaseTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsChar
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAsChar
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAsChar
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle(char[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle(char[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle(char[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle(char[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
@ -93,7 +95,6 @@ public class VarHandleTestByteArrayAsChar extends VarHandleBaseByteArrayTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsDouble
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAsDouble
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAsDouble
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle(double[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle(double[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle(double[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle(double[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
@ -93,7 +95,6 @@ public class VarHandleTestByteArrayAsDouble extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsFloat
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAsFloat
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAsFloat
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle(float[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle(float[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle(float[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle(float[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
@ -93,7 +95,6 @@ public class VarHandleTestByteArrayAsFloat extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsInt
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAsInt
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAsInt
|
||||
@ -37,10 +38,10 @@ import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.EnumSet;
|
||||
import java.util.List;
|
||||
|
||||
import static org.testng.Assert.*;
|
||||
import static org.testng.Assert.assertEquals;
|
||||
import static org.testng.Assert.assertTrue;
|
||||
|
||||
public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest {
|
||||
static final int SIZE = Integer.BYTES;
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle(int[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle(int[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle(int[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle(int[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
@ -93,7 +95,6 @@ public class VarHandleTestByteArrayAsInt extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsLong
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAsLong
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAsLong
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle(long[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle(long[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle(long[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle(long[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
@ -93,7 +95,6 @@ public class VarHandleTestByteArrayAsLong extends VarHandleBaseByteArrayTest {
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAsShort
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAsShort
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAsShort
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle(short[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle(short[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle(short[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle(short[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
@ -93,7 +95,6 @@ public class VarHandleTestByteArrayAsShort extends VarHandleBaseByteArrayTest {
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
|
||||
|
||||
assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
|
||||
|
@ -23,6 +23,7 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8154556
|
||||
* @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAs$Type$
|
||||
* @run testng/othervm -Diters=20000 VarHandleTestByteArrayAs$Type$
|
||||
* @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestByteArrayAs$Type$
|
||||
@ -57,15 +58,16 @@ public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest {
|
||||
// Combinations of VarHandle byte[] or ByteBuffer
|
||||
vhss = new ArrayList<>();
|
||||
for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
|
||||
|
||||
ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
|
||||
? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
|
||||
VarHandleSource aeh = new VarHandleSource(
|
||||
MethodHandles.byteArrayViewVarHandle($type$[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteArrayViewVarHandle($type$[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(aeh);
|
||||
|
||||
VarHandleSource bbh = new VarHandleSource(
|
||||
MethodHandles.byteBufferViewVarHandle($type$[].class,
|
||||
endianess == MemoryMode.BIG_ENDIAN),
|
||||
MethodHandles.byteBufferViewVarHandle($type$[].class, bo),
|
||||
endianess, MemoryMode.READ_WRITE);
|
||||
vhss.add(bbh);
|
||||
}
|
||||
|
@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 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.
|
||||
*/
|
||||
|
||||
package java.util.concurrent;
|
||||
|
||||
import java.lang.invoke.MethodHandles;
|
||||
|
||||
public class LookupTester {
|
||||
public static MethodHandles.Lookup getLookup() {
|
||||
return MethodHandles.lookup();
|
||||
}
|
||||
|
||||
|
||||
public static MethodHandles.Lookup getLookupIn() {
|
||||
return MethodHandles.lookup().in(ConcurrentHashMap.class);
|
||||
}
|
||||
}
|
@ -23,11 +23,13 @@
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8036979 8072384
|
||||
* @bug 8036979 8072384 8044773
|
||||
* @run main/othervm -Xcheck:jni OptionsTest
|
||||
* @run main/othervm -Xcheck:jni -Djava.net.preferIPv4Stack=true OptionsTest
|
||||
* @run main/othervm -Djdk.launcher.limitmods=java.base OptionsTest
|
||||
*/
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
import java.net.*;
|
||||
import java.util.*;
|
||||
|
||||
@ -43,7 +45,7 @@ public class OptionsTest {
|
||||
}
|
||||
Object option;
|
||||
Object testValue;
|
||||
};
|
||||
}
|
||||
|
||||
// The tests set the option using the new API, read back the set value
|
||||
// which could be diferent, and then use the legacy get API to check
|
||||
@ -223,8 +225,7 @@ public class OptionsTest {
|
||||
} else if (option.equals(StandardSocketOptions.SO_REUSEPORT) && reuseport) {
|
||||
return Boolean.valueOf(socket.getOption(StandardSocketOptions.SO_REUSEPORT));
|
||||
} else if (option.equals(StandardSocketOptions.IP_TOS)) {
|
||||
return Integer.valueOf(jdk.net.Sockets.getOption(
|
||||
socket, StandardSocketOptions.IP_TOS));
|
||||
return getServerSocketTrafficClass(socket);
|
||||
} else {
|
||||
throw new RuntimeException("unexecpted socket option");
|
||||
}
|
||||
@ -281,4 +282,20 @@ public class OptionsTest {
|
||||
doDgSocketTests();
|
||||
doMcSocketTests();
|
||||
}
|
||||
|
||||
// Reflectively access jdk.net.Sockets.getOption so that the test can run
|
||||
// without the jdk.net module.
|
||||
static Object getServerSocketTrafficClass(ServerSocket ss) throws Exception {
|
||||
try {
|
||||
Class<?> c = Class.forName("jdk.net.Sockets");
|
||||
Method m = c.getDeclaredMethod("getOption", ServerSocket.class, SocketOption.class);
|
||||
return m.invoke(null, ss, StandardSocketOptions.IP_TOS);
|
||||
} catch (ClassNotFoundException e) {
|
||||
// Ok, jdk.net module not present, just fall back
|
||||
System.out.println("jdk.net module not present, falling back.");
|
||||
return Integer.valueOf(ss.getOption(StandardSocketOptions.IP_TOS));
|
||||
} catch (ReflectiveOperationException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -21,34 +21,48 @@
|
||||
* questions.
|
||||
*/
|
||||
|
||||
import jdk.net.ExtendedSocketOptions;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Field;
|
||||
import java.net.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 8143554
|
||||
* @run main UnsupportedOptionsTest
|
||||
* @bug 8143554 8044773
|
||||
* @summary Test checks that UnsupportedOperationException for unsupported
|
||||
* SOCKET_OPTIONS is thrown by both getOption() and setOption() methods.
|
||||
* @run main UnsupportedOptionsTest
|
||||
* @run main/othervm -Djdk.launcher.limitmods=java.base UnsupportedOptionsTest
|
||||
*/
|
||||
|
||||
public class UnsupportedOptionsTest {
|
||||
|
||||
private static final SocketOption[] SOCKET_OPTIONS = {
|
||||
StandardSocketOptions.IP_MULTICAST_IF,
|
||||
StandardSocketOptions.IP_MULTICAST_LOOP,
|
||||
StandardSocketOptions.IP_MULTICAST_TTL,
|
||||
StandardSocketOptions.IP_TOS,
|
||||
StandardSocketOptions.SO_BROADCAST,
|
||||
StandardSocketOptions.SO_KEEPALIVE,
|
||||
StandardSocketOptions.SO_LINGER,
|
||||
StandardSocketOptions.SO_RCVBUF,
|
||||
StandardSocketOptions.SO_REUSEADDR,
|
||||
StandardSocketOptions.SO_SNDBUF,
|
||||
StandardSocketOptions.TCP_NODELAY,
|
||||
ExtendedSocketOptions.SO_FLOW_SLA
|
||||
};
|
||||
private static final List<SocketOption<?>> socketOptions = new ArrayList<>();
|
||||
|
||||
static {
|
||||
socketOptions.add(StandardSocketOptions.IP_MULTICAST_IF);
|
||||
socketOptions.add(StandardSocketOptions.IP_MULTICAST_LOOP);
|
||||
socketOptions.add(StandardSocketOptions.IP_MULTICAST_TTL);
|
||||
socketOptions.add(StandardSocketOptions.IP_TOS);
|
||||
socketOptions.add(StandardSocketOptions.SO_BROADCAST);
|
||||
socketOptions.add(StandardSocketOptions.SO_KEEPALIVE);
|
||||
socketOptions.add(StandardSocketOptions.SO_LINGER);
|
||||
socketOptions.add(StandardSocketOptions.SO_RCVBUF);
|
||||
socketOptions.add(StandardSocketOptions.SO_REUSEADDR);
|
||||
socketOptions.add(StandardSocketOptions.SO_SNDBUF);
|
||||
socketOptions.add(StandardSocketOptions.TCP_NODELAY);
|
||||
|
||||
try {
|
||||
Class<?> c = Class.forName("jdk.net.ExtendedSocketOptions");
|
||||
Field field = c.getField("SO_FLOW_SLA");
|
||||
socketOptions.add((SocketOption<?>)field.get(null));
|
||||
} catch (ClassNotFoundException e) {
|
||||
// ignore, jdk.net module not present
|
||||
} catch (ReflectiveOperationException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String[] args) throws IOException {
|
||||
Socket s = new Socket();
|
||||
@ -56,7 +70,7 @@ public class UnsupportedOptionsTest {
|
||||
DatagramSocket ds = new DatagramSocket();
|
||||
MulticastSocket ms = new MulticastSocket();
|
||||
|
||||
for (SocketOption option : SOCKET_OPTIONS) {
|
||||
for (SocketOption option : socketOptions) {
|
||||
if (!s.supportedOptions().contains(option)) {
|
||||
testUnsupportedSocketOption(s, option);
|
||||
}
|
||||
|
@ -22,8 +22,10 @@
|
||||
*/
|
||||
|
||||
/* @test
|
||||
* @bug 4640544
|
||||
* @bug 4640544 8044773
|
||||
* @summary Unit test for setOption/getOption/options methods
|
||||
* @run main SocketOptionTests
|
||||
* @run main/othervm -Djdk.launcher.limitmods=java.base SocketOptionTests
|
||||
*/
|
||||
|
||||
import java.nio.*;
|
||||
|
@ -22,9 +22,11 @@
|
||||
*/
|
||||
|
||||
/* @test
|
||||
* @bug 4640544
|
||||
* @bug 4640544 8044773
|
||||
* @summary Unit test for ServerSocketChannel setOption/getOption/options
|
||||
* methods.
|
||||
* @run main SocketOptionTests
|
||||
* @run main/othervm -Djdk.launcher.limitmods=java.base SocketOptionTests
|
||||
*/
|
||||
|
||||
import java.nio.*;
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user