src/main/java/org/apache/maven/buildcache/hash/CloseableBuffer.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF 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 org.apache.maven.buildcache.hash;

import java.io.IOException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.security.PrivilegedAction;

import static java.security.AccessController.doPrivileged;
import static org.apache.maven.buildcache.hash.ReflectionUtils.getField;
import static org.apache.maven.buildcache.hash.ReflectionUtils.getMethod;

/**
 * CloseableBuffer https://stackoverflow.com/a/54046774
 */
public class CloseableBuffer implements AutoCloseable
{

    private static final Cleaner CLEANER = doPrivileged( new PrivilegedAction<Cleaner>()
    {

        @Override
        public Cleaner run()
        {
            final String jsv = System.getProperty( "java.specification.version", "9" );
            if ( jsv.startsWith( "1." ) )
            {
                return DirectCleaner.isSupported() ? new DirectCleaner() : new NoopCleaner();
            }
            else
            {
                return UnsafeCleaner.isSupported() ? new UnsafeCleaner() : new NoopCleaner();
            }
        }
    } );

    public static CloseableBuffer directBuffer( int capacity )
    {
        return new CloseableBuffer( ByteBuffer.allocateDirect( capacity ) );
    }

    public static CloseableBuffer mappedBuffer( FileChannel channel, MapMode mode ) throws IOException
    {
        return new CloseableBuffer( channel.map( mode, 0, channel.size() ) );
    }

    private ByteBuffer buffer;

    /**
     * Unmap only DirectByteBuffer and MappedByteBuffer
     */
    private CloseableBuffer( ByteBuffer buffer )
    {
        // Java 8: buffer.isDirect()
        this.buffer = buffer;
    }

    /**
     * Do not use buffer after close
     */
    public ByteBuffer getBuffer()
    {
        return buffer;
    }

    @Override
    public void close()
    {
        // Java 8: () -> CLEANER.clean(buffer)
        boolean done = doPrivileged( new PrivilegedAction<Boolean>()
        {

            @Override
            public Boolean run()
            {
                return CLEANER.clean( buffer );
            }
        } );
        if ( done )
        {
            buffer = null;
        }
    }

    // Java 8: @FunctionalInterface
    private interface Cleaner
    {

        boolean clean( ByteBuffer buffer );
    }

    private static class NoopCleaner implements Cleaner
    {

        @Override
        public boolean clean( ByteBuffer buffer )
        {
            return false;
        }
    }

    private static class DirectCleaner implements Cleaner
    {

        private static final Method ATTACHMENT = getMethod( "sun.nio.ch.DirectBuffer",
                        "attachment" );

        private static final Method CLEANER = getMethod( "sun.nio.ch.DirectBuffer", "cleaner" );

        private static final Method CLEAN = getMethod( "sun.misc.Cleaner", "clean" );

        public static boolean isSupported()
        {
            return ATTACHMENT != null && CLEAN != null && CLEANER != null;
        }

        /**
         * Make sure duplicates and slices are not cleaned, since this can result in duplicate attempts to clean the
         * same buffer, which trigger a crash with: "A fatal error has been detected by the Java Runtime Environment:
         * EXCEPTION_ACCESS_VIOLATION" See: https://stackoverflow.com/a/31592947/3950982
         */
        @Override
        public boolean clean( ByteBuffer buffer )
        {
            try
            {
                if ( ATTACHMENT.invoke( buffer ) == null )
                {
                    CLEAN.invoke( CLEANER.invoke( buffer ) );
                    return true;
                }
            }
            catch ( Exception ignore )
            {
            }
            return false;
        }
    }

    private static class UnsafeCleaner implements Cleaner
    {

        // Java 9: getMethod("jdk.internal.misc.Unsafe", "invokeCleaner", ByteBuffer.class);
        private static final Method INVOKE_CLEANER = getMethod( "sun.misc.Unsafe", "invokeCleaner", ByteBuffer.class );

        private static final Object UNSAFE = getField( "sun.misc.Unsafe", "theUnsafe" );

        public static boolean isSupported()
        {
            return UNSAFE != null && INVOKE_CLEANER != null;
        }

        /**
         * Calling the above code in JDK9+ gives a reflection warning on stderr,
         * Unsafe.theUnsafe.invokeCleaner(byteBuffer) makes the same call, but does not print the reflection warning
         */
        @Override
        public boolean clean( ByteBuffer buffer )
        {
            try
            {
                // throws IllegalArgumentException if buffer is a duplicate or slice
                INVOKE_CLEANER.invoke( UNSAFE, buffer );
                return true;
            }
            catch ( Exception ignore )
            {
            }
            return false;
        }
    }
}