114 lines
4.3 KiB
Java
114 lines
4.3 KiB
Java
/*
|
|
* Copyright 2017 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.util.internal;
|
|
|
|
import io.netty.util.internal.logging.InternalLogger;
|
|
import io.netty.util.internal.logging.InternalLoggerFactory;
|
|
|
|
import java.lang.invoke.MethodHandle;
|
|
import java.lang.invoke.MethodHandles;
|
|
import java.lang.invoke.MethodType;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.nio.ByteBuffer;
|
|
import java.security.AccessController;
|
|
import java.security.PrivilegedAction;
|
|
|
|
/**
|
|
* Provide a way to clean a ByteBuffer on Java9+.
|
|
*/
|
|
final class CleanerJava9 implements Cleaner {
|
|
private static final InternalLogger logger = InternalLoggerFactory.getInstance(CleanerJava9.class);
|
|
|
|
private static final MethodHandle INVOKE_CLEANER_HANDLE;
|
|
|
|
static {
|
|
final MethodHandle invokeCleanerHandle;
|
|
final Throwable error;
|
|
if (PlatformDependent0.hasUnsafe()) {
|
|
final ByteBuffer buffer = ByteBuffer.allocateDirect(1);
|
|
Object maybeInvokeMethodHandle = AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
|
|
try {
|
|
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
|
// See https://bugs.openjdk.java.net/browse/JDK-8171377
|
|
MethodHandle m = lookup.findVirtual(
|
|
PlatformDependent0.UNSAFE.getClass(),
|
|
"invokeCleaner",
|
|
MethodType.methodType(void.class, ByteBuffer.class)).bindTo(PlatformDependent0.UNSAFE);
|
|
m.invokeExact(buffer);
|
|
return m;
|
|
} catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
|
|
return e;
|
|
} catch (Throwable cause) {
|
|
PlatformDependent0.throwException(cause);
|
|
return cause;
|
|
}
|
|
});
|
|
|
|
if (maybeInvokeMethodHandle instanceof Throwable) {
|
|
invokeCleanerHandle = null;
|
|
error = (Throwable) maybeInvokeMethodHandle;
|
|
} else {
|
|
invokeCleanerHandle = (MethodHandle) maybeInvokeMethodHandle;
|
|
error = null;
|
|
}
|
|
} else {
|
|
invokeCleanerHandle = null;
|
|
error = new UnsupportedOperationException("sun.misc.Unsafe unavailable");
|
|
}
|
|
if (error == null) {
|
|
logger.debug("java.nio.ByteBuffer.cleaner(): available");
|
|
} else {
|
|
logger.debug("java.nio.ByteBuffer.cleaner(): unavailable", error);
|
|
}
|
|
INVOKE_CLEANER_HANDLE = invokeCleanerHandle;
|
|
}
|
|
|
|
static boolean isSupported() {
|
|
return INVOKE_CLEANER_HANDLE != null;
|
|
}
|
|
|
|
@Override
|
|
public void freeDirectBuffer(ByteBuffer buffer) {
|
|
// Try to minimize overhead when there is no SecurityManager present.
|
|
// See https://bugs.openjdk.java.net/browse/JDK-8191053.
|
|
if (System.getSecurityManager() == null) {
|
|
try {
|
|
INVOKE_CLEANER_HANDLE.invokeExact(buffer);
|
|
} catch (Throwable cause) {
|
|
PlatformDependent0.throwException(cause);
|
|
}
|
|
} else {
|
|
freeDirectBufferPrivileged(buffer);
|
|
}
|
|
}
|
|
|
|
private static void freeDirectBufferPrivileged(final ByteBuffer buffer) {
|
|
Exception error = AccessController.doPrivileged((PrivilegedAction<Exception>) () -> {
|
|
try {
|
|
INVOKE_CLEANER_HANDLE.invokeExact(PlatformDependent0.UNSAFE, buffer);
|
|
} catch (InvocationTargetException | IllegalAccessException e) {
|
|
return e;
|
|
} catch (Throwable cause) {
|
|
PlatformDependent.throwException(cause);
|
|
}
|
|
return null;
|
|
});
|
|
if (error != null) {
|
|
PlatformDependent0.throwException(error);
|
|
}
|
|
}
|
|
}
|