/*

 * Copyright (c) 2000, 2017, 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 "jni_util.h"

#include "jvm.h"

#include "jlong.h"

#include "sun_nio_ch_FileDispatcherImpl.h"

#include "java_lang_Long.h"

#include <sys/types.h>

#include <sys/socket.h>

#include <fcntl.h>

#include <sys/uio.h>

#include <unistd.h>

#include <sys/statvfs.h>

#if defined(__linux__)

#include <linux/fs.h>

#include <sys/ioctl.h>

#endif

#include "nio.h"

#include "nio_util.h"

#ifdef _ALLBSD_SOURCE

#define stat64 stat

#define flock64 flock

#define off64_t off_t

#define F_SETLKW64 F_SETLKW

#define F_SETLK64 F_SETLK

#define pread64 pread

#define pwrite64 pwrite

#define ftruncate64 ftruncate

#define fstat64 fstat

#define fdatasync fsync

#endif

static int preCloseFD = -1;     /* File descriptor to which we dup other fd's

                                   before closing them for real */

JNIEXPORT void JNICALL

Java_sun_nio_ch_FileDispatcherImpl_init(JNIEnv *env, jclass cl)

{

    int sp[2];

    if (socketpair(PF_UNIX, SOCK_STREAM, 0, sp) < 0) {

        JNU_ThrowIOExceptionWithLastError(env, "socketpair failed");

        return;

    }

    preCloseFD = sp[0];

    close(sp[1]);

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_read0(JNIEnv *env, jclass clazz,

                             jobject fdo, jlong address, jint len)

{

    jint fd = fdval(env, fdo);

    void *buf = (void *)jlong_to_ptr(address);

    return convertReturnVal(env, read(fd, buf, len), JNI_TRUE);

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_pread0(JNIEnv *env, jclass clazz, jobject fdo,

                            jlong address, jint len, jlong offset)

{

    jint fd = fdval(env, fdo);

    void *buf = (void *)jlong_to_ptr(address);

    return convertReturnVal(env, pread64(fd, buf, len, offset), JNI_TRUE);

}

JNIEXPORT jlong JNICALL

Java_sun_nio_ch_FileDispatcherImpl_readv0(JNIEnv *env, jclass clazz,

                              jobject fdo, jlong address, jint len)

{

    jint fd = fdval(env, fdo);

    struct iovec *iov = (struct iovec *)jlong_to_ptr(address);

    return convertLongReturnVal(env, readv(fd, iov, len), JNI_TRUE);

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_write0(JNIEnv *env, jclass clazz,

                              jobject fdo, jlong address, jint len)

{

    jint fd = fdval(env, fdo);

    void *buf = (void *)jlong_to_ptr(address);

    return convertReturnVal(env, write(fd, buf, len), JNI_FALSE);

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_pwrite0(JNIEnv *env, jclass clazz, jobject fdo,

                            jlong address, jint len, jlong offset)

{

    jint fd = fdval(env, fdo);

    void *buf = (void *)jlong_to_ptr(address);

    return convertReturnVal(env, pwrite64(fd, buf, len, offset), JNI_FALSE);

}

JNIEXPORT jlong JNICALL

Java_sun_nio_ch_FileDispatcherImpl_writev0(JNIEnv *env, jclass clazz,

                                       jobject fdo, jlong address, jint len)

{

    jint fd = fdval(env, fdo);

    struct iovec *iov = (struct iovec *)jlong_to_ptr(address);

    return convertLongReturnVal(env, writev(fd, iov, len), JNI_FALSE);

}

static jlong

handle(JNIEnv *env, jlong rv, char *msg)

{

    if (rv >= 0)

        return rv;

    if (errno == EINTR)

        return IOS_INTERRUPTED;

    JNU_ThrowIOExceptionWithLastError(env, msg);

    return IOS_THROWN;

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_force0(JNIEnv *env, jobject this,

                                          jobject fdo, jboolean md)

{

    jint fd = fdval(env, fdo);

    int result = 0;

#ifdef MACOSX

    result = fcntl(fd, F_FULLFSYNC);

    if (result == -1 && errno == ENOTSUP) {

        /* Try fsync() in case F_FULLSYUNC is not implemented on the file system. */

        result = fsync(fd);

    }

#else /* end MACOSX, begin not-MACOSX */

    if (md == JNI_FALSE) {

        result = fdatasync(fd);

    } else {

#ifdef _AIX

        /* On AIX, calling fsync on a file descriptor that is opened only for

         * reading results in an error ("EBADF: The FileDescriptor parameter is

         * not a valid file descriptor open for writing.").

         * However, at this point it is not possibly anymore to read the

         * 'writable' attribute of the corresponding file channel so we have to

         * use 'fcntl'.

         */

        int getfl = fcntl(fd, F_GETFL);

        if (getfl >= 0 && (getfl & O_ACCMODE) == O_RDONLY) {

            return 0;

        }

#endif /* _AIX */

        result = fsync(fd);

    }

#endif /* not-MACOSX */

    return handle(env, result, "Force failed");

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_truncate0(JNIEnv *env, jobject this,

                                             jobject fdo, jlong size)

{

    return handle(env,

                  ftruncate64(fdval(env, fdo), size),

                  "Truncation failed");

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_allocate0(JNIEnv *env, jobject this,

                                             jobject fdo, jlong size)

{

#if defined(__linux__)

    /*

     * On Linux, if the file size is being increased, then ftruncate64()

     * will modify the metadata value of the size without actually allocating

     * any blocks which can cause a SIGBUS error if the file is subsequently

     * memory-mapped.

     */

    // Return on success or if errno is neither EOPNOTSUPP nor ENOSYS

    int result = fallocate64(fdval(env, fdo), 0, 0, size);

    if (result == 0) {

        return 0;

    } else if (errno != EOPNOTSUPP && errno != ENOSYS) {

        return handle(env, result, "Allocation failed");

    }

#endif

    return handle(env,

                  ftruncate64(fdval(env, fdo), size),

                  "Truncation failed");

}

JNIEXPORT jlong JNICALL

Java_sun_nio_ch_FileDispatcherImpl_size0(JNIEnv *env, jobject this, jobject fdo)

{

    jint fd = fdval(env, fdo);

    struct stat64 fbuf;

    if (fstat64(fd, &fbuf) < 0)

        return handle(env, -1, "Size failed");

#ifdef BLKGETSIZE64

    if (S_ISBLK(fbuf.st_mode)) {

        uint64_t size;

        if (ioctl(fd, BLKGETSIZE64, &size) < 0)

            return handle(env, -1, "Size failed");

        return (jlong)size;

    }

#endif

    return fbuf.st_size;

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_lock0(JNIEnv *env, jobject this, jobject fdo,

                                      jboolean block, jlong pos, jlong size,

                                      jboolean shared)

{

    jint fd = fdval(env, fdo);

    jint lockResult = 0;

    int cmd = 0;

    struct flock64 fl;

    fl.l_whence = SEEK_SET;

    if (size == (jlong)java_lang_Long_MAX_VALUE) {

        fl.l_len = (off64_t)0;

    } else {

        fl.l_len = (off64_t)size;

    }

    fl.l_start = (off64_t)pos;

    if (shared == JNI_TRUE) {

        fl.l_type = F_RDLCK;

    } else {

        fl.l_type = F_WRLCK;

    }

    if (block == JNI_TRUE) {

        cmd = F_SETLKW64;

    } else {

        cmd = F_SETLK64;

    }

    lockResult = fcntl(fd, cmd, &fl);

    if (lockResult < 0) {

        if ((cmd == F_SETLK64) && (errno == EAGAIN || errno == EACCES))

            return sun_nio_ch_FileDispatcherImpl_NO_LOCK;

        if (errno == EINTR)

            return sun_nio_ch_FileDispatcherImpl_INTERRUPTED;

        JNU_ThrowIOExceptionWithLastError(env, "Lock failed");

    }

    return 0;

}

JNIEXPORT void JNICALL

Java_sun_nio_ch_FileDispatcherImpl_release0(JNIEnv *env, jobject this,

                                         jobject fdo, jlong pos, jlong size)

{

    jint fd = fdval(env, fdo);

    jint lockResult = 0;

    struct flock64 fl;

    int cmd = F_SETLK64;

    fl.l_whence = SEEK_SET;

    if (size == (jlong)java_lang_Long_MAX_VALUE) {

        fl.l_len = (off64_t)0;

    } else {

        fl.l_len = (off64_t)size;

    }

    fl.l_start = (off64_t)pos;

    fl.l_type = F_UNLCK;

    lockResult = fcntl(fd, cmd, &fl);

    if (lockResult < 0) {

        JNU_ThrowIOExceptionWithLastError(env, "Release failed");

    }

}

static void closeFileDescriptor(JNIEnv *env, int fd) {

    if (fd != -1) {

        int result = close(fd);

        if (result < 0)

            JNU_ThrowIOExceptionWithLastError(env, "Close failed");

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_ch_FileDispatcherImpl_close0(JNIEnv *env, jclass clazz, jobject fdo)

{

    jint fd = fdval(env, fdo);

    closeFileDescriptor(env, fd);

}

JNIEXPORT void JNICALL

Java_sun_nio_ch_FileDispatcherImpl_preClose0(JNIEnv *env, jclass clazz, jobject fdo)

{

    jint fd = fdval(env, fdo);

    if (preCloseFD >= 0) {

        if (dup2(preCloseFD, fd) < 0)

            JNU_ThrowIOExceptionWithLastError(env, "dup2 failed");

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_ch_FileDispatcherImpl_closeIntFD(JNIEnv *env, jclass clazz, jint fd)

{

    closeFileDescriptor(env, fd);

}

JNIEXPORT jint JNICALL

Java_sun_nio_ch_FileDispatcherImpl_setDirect0(JNIEnv *env, jclass clazz,

                                           jobject fdo)

{

    jint fd = fdval(env, fdo);

    jint result;

#ifdef MACOSX

    struct statvfs file_stat;

#else

    struct statvfs64 file_stat;

#endif

#if defined(O_DIRECT) || defined(F_NOCACHE) || defined(DIRECTIO_ON)

#ifdef O_DIRECT

    jint orig_flag;

    orig_flag = fcntl(fd, F_GETFL);

    if (orig_flag == -1) {

        JNU_ThrowIOExceptionWithLastError(env, "DirectIO setup failed");

        return -1;

    }

    result = fcntl(fd, F_SETFL, orig_flag | O_DIRECT);

    if (result == -1) {

        JNU_ThrowIOExceptionWithLastError(env, "DirectIO setup failed");

        return result;

    }

#elif F_NOCACHE

    result = fcntl(fd, F_NOCACHE, 1);

    if (result == -1) {

        JNU_ThrowIOExceptionWithLastError(env, "DirectIO setup failed");

        return result;

    }

#elif DIRECTIO_ON

    result = directio(fd, DIRECTIO_ON);

    if (result == -1) {

        JNU_ThrowIOExceptionWithLastError(env, "DirectIO setup failed");

        return result;

    }

#endif

#ifdef MACOSX

    result = fstatvfs(fd, &file_stat);

#else

    result = fstatvfs64(fd, &file_stat);

#endif

    if(result == -1) {

        JNU_ThrowIOExceptionWithLastError(env, "DirectIO setup failed");

        return result;

    } else {

        result = (int)file_stat.f_frsize;

    }

#else

    result == -1;

#endif

    return result;

}