--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/sun/nio/ch/IOUtil.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,363 @@
+/*
+ * Copyright 2000-2002 Sun Microsystems, Inc. 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. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package sun.nio.ch;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.net.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.*;
+import java.nio.channels.spi.*;
+
+
+/**
+ * File-descriptor based I/O utilities that are shared by NIO classes.
+ */
+
+class IOUtil {
+
+ private IOUtil() { } // No instantiation
+
+ /*
+ * Returns the index of first buffer in bufs with remaining,
+ * or -1 if there is nothing left
+ */
+ private static int remaining(ByteBuffer[] bufs) {
+ int numBufs = bufs.length;
+ boolean remaining = false;
+ for (int i=0; i<numBufs; i++) {
+ if (bufs[i].hasRemaining()) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /*
+ * Returns a new ByteBuffer array with only unfinished buffers in it
+ */
+ private static ByteBuffer[] skipBufs(ByteBuffer[] bufs,
+ int nextWithRemaining)
+ {
+ int newSize = bufs.length - nextWithRemaining;
+ ByteBuffer[] temp = new ByteBuffer[newSize];
+ for (int i=0; i<newSize; i++) {
+ temp[i] = bufs[i + nextWithRemaining];
+ }
+ return temp;
+ }
+
+ static int write(FileDescriptor fd, ByteBuffer src, long position,
+ NativeDispatcher nd, Object lock)
+ throws IOException
+ {
+ if (src instanceof DirectBuffer)
+ return writeFromNativeBuffer(fd, src, position, nd, lock);
+
+ // Substitute a native buffer
+ int pos = src.position();
+ int lim = src.limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+ ByteBuffer bb = null;
+ try {
+ bb = Util.getTemporaryDirectBuffer(rem);
+ bb.put(src);
+ bb.flip();
+ // Do not update src until we see how many bytes were written
+ src.position(pos);
+
+ int n = writeFromNativeBuffer(fd, bb, position, nd, lock);
+ if (n > 0) {
+ // now update src
+ src.position(pos + n);
+ }
+ return n;
+ } finally {
+ Util.releaseTemporaryDirectBuffer(bb);
+ }
+ }
+
+ private static int writeFromNativeBuffer(FileDescriptor fd, ByteBuffer bb,
+ long position, NativeDispatcher nd,
+ Object lock)
+ throws IOException
+ {
+ int pos = bb.position();
+ int lim = bb.limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+
+ int written = 0;
+ if (rem == 0)
+ return 0;
+ if (position != -1) {
+ written = nd.pwrite(fd,
+ ((DirectBuffer)bb).address() + pos,
+ rem, position, lock);
+ } else {
+ written = nd.write(fd, ((DirectBuffer)bb).address() + pos, rem);
+ }
+ if (written > 0)
+ bb.position(pos + written);
+ return written;
+ }
+
+ static long write(FileDescriptor fd, ByteBuffer[] bufs, NativeDispatcher nd)
+ throws IOException
+ {
+ int nextWithRemaining = remaining(bufs);
+ // if all bufs are empty we should return immediately
+ if (nextWithRemaining < 0)
+ return 0;
+ // If some bufs are empty we should skip them
+ if (nextWithRemaining > 0)
+ bufs = skipBufs(bufs, nextWithRemaining);
+
+ int numBufs = bufs.length;
+ int bytesReadyToWrite = 0;
+
+ // Create shadow to ensure DirectByteBuffers are used
+ ByteBuffer[] shadow = new ByteBuffer[numBufs];
+ for (int i=0; i<numBufs; i++) {
+ if (!(bufs[i] instanceof DirectBuffer)) {
+ int pos = bufs[i].position();
+ int lim = bufs[i].limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+
+ ByteBuffer bb = ByteBuffer.allocateDirect(rem);
+ shadow[i] = bb;
+ // Leave slow buffer position untouched; it will be updated
+ // after we see how many bytes were really written out
+ bb.put(bufs[i]);
+ bufs[i].position(pos);
+ bb.flip();
+ } else {
+ shadow[i] = bufs[i];
+ }
+ }
+
+ IOVecWrapper vec = null;
+ long bytesWritten = 0;
+ try {
+ // Create a native iovec array
+ vec= new IOVecWrapper(numBufs);
+
+ // Fill in the iovec array with appropriate data
+ for (int i=0; i<numBufs; i++) {
+ ByteBuffer nextBuffer = shadow[i];
+ // put in the buffer addresses
+ long pos = nextBuffer.position();
+ long len = nextBuffer.limit() - pos;
+ bytesReadyToWrite += len;
+ vec.putBase(i, ((DirectBuffer)nextBuffer).address() + pos);
+ vec.putLen(i, len);
+ }
+
+ // Invoke native call to fill the buffers
+ bytesWritten = nd.writev(fd, vec.address, numBufs);
+ } finally {
+ vec.free();
+ }
+ long returnVal = bytesWritten;
+
+ // Notify the buffers how many bytes were taken
+ for (int i=0; i<numBufs; i++) {
+ ByteBuffer nextBuffer = bufs[i];
+ int pos = nextBuffer.position();
+ int lim = nextBuffer.limit();
+ assert (pos <= lim);
+ int len = (pos <= lim ? lim - pos : lim);
+ if (bytesWritten >= len) {
+ bytesWritten -= len;
+ int newPosition = pos + len;
+ nextBuffer.position(newPosition);
+ } else { // Buffers not completely filled
+ if (bytesWritten > 0) {
+ assert(pos + bytesWritten < (long)Integer.MAX_VALUE);
+ int newPosition = (int)(pos + bytesWritten);
+ nextBuffer.position(newPosition);
+ }
+ break;
+ }
+ }
+ return returnVal;
+ }
+
+ static int read(FileDescriptor fd, ByteBuffer dst, long position,
+ NativeDispatcher nd, Object lock)
+ throws IOException
+ {
+ if (dst.isReadOnly())
+ throw new IllegalArgumentException("Read-only buffer");
+ if (dst instanceof DirectBuffer)
+ return readIntoNativeBuffer(fd, dst, position, nd, lock);
+
+ // Substitute a native buffer
+ ByteBuffer bb = null;
+ try {
+ bb = Util.getTemporaryDirectBuffer(dst.remaining());
+ int n = readIntoNativeBuffer(fd, bb, position, nd, lock);
+ bb.flip();
+ if (n > 0)
+ dst.put(bb);
+ return n;
+ } finally {
+ Util.releaseTemporaryDirectBuffer(bb);
+ }
+ }
+
+ private static int readIntoNativeBuffer(FileDescriptor fd, ByteBuffer bb,
+ long position, NativeDispatcher nd,
+ Object lock)
+ throws IOException
+ {
+ int pos = bb.position();
+ int lim = bb.limit();
+ assert (pos <= lim);
+ int rem = (pos <= lim ? lim - pos : 0);
+
+ if (rem == 0)
+ return 0;
+ int n = 0;
+ if (position != -1) {
+ n = nd.pread(fd, ((DirectBuffer)bb).address() + pos,
+ rem, position, lock);
+ } else {
+ n = nd.read(fd, ((DirectBuffer)bb).address() + pos, rem);
+ }
+ if (n > 0)
+ bb.position(pos + n);
+ return n;
+ }
+
+ static long read(FileDescriptor fd, ByteBuffer[] bufs, NativeDispatcher nd)
+ throws IOException
+ {
+ int nextWithRemaining = remaining(bufs);
+ // if all bufs are empty we should return immediately
+ if (nextWithRemaining < 0)
+ return 0;
+ // If some bufs are empty we should skip them
+ if (nextWithRemaining > 0)
+ bufs = skipBufs(bufs, nextWithRemaining);
+
+ int numBufs = bufs.length;
+
+ // Read into the shadow to ensure DirectByteBuffers are used
+ ByteBuffer[] shadow = new ByteBuffer[numBufs];
+ for (int i=0; i<numBufs; i++) {
+ if (bufs[i].isReadOnly())
+ throw new IllegalArgumentException("Read-only buffer");
+ if (!(bufs[i] instanceof DirectBuffer)) {
+ shadow[i] = ByteBuffer.allocateDirect(bufs[i].remaining());
+ } else {
+ shadow[i] = bufs[i];
+ }
+ }
+
+ IOVecWrapper vec = null;
+ long bytesRead = 0;
+ try {
+ // Create a native iovec array
+ vec = new IOVecWrapper(numBufs);
+
+ // Fill in the iovec array with appropriate data
+ for (int i=0; i<numBufs; i++) {
+ ByteBuffer nextBuffer = shadow[i];
+ // put in the buffer addresses
+ long pos = nextBuffer.position();
+ long len = nextBuffer.remaining();
+ vec.putBase(i, ((DirectBuffer)nextBuffer).address() + pos);
+ vec.putLen(i, len);
+ }
+
+ // Invoke native call to fill the buffers
+ bytesRead = nd.readv(fd, vec.address, numBufs);
+ } finally {
+ vec.free();
+ }
+ long returnVal = bytesRead;
+
+ // Notify the buffers how many bytes were read
+ for (int i=0; i<numBufs; i++) {
+ ByteBuffer nextBuffer = shadow[i];
+ // Note: should this have been cached from above?
+ int pos = nextBuffer.position();
+ int len = nextBuffer.remaining();
+ if (bytesRead >= len) {
+ bytesRead -= len;
+ int newPosition = pos + len;
+ nextBuffer.position(newPosition);
+ } else { // Buffers not completely filled
+ if (bytesRead > 0) {
+ assert(pos + bytesRead < (long)Integer.MAX_VALUE);
+ int newPosition = (int)(pos + bytesRead);
+ nextBuffer.position(newPosition);
+ }
+ break;
+ }
+ }
+
+ // Put results from shadow into the slow buffers
+ for (int i=0; i<numBufs; i++) {
+ if (!(bufs[i] instanceof DirectBuffer)) {
+ shadow[i].flip();
+ bufs[i].put(shadow[i]);
+ }
+ }
+
+ return returnVal;
+ }
+
+ static FileDescriptor newFD(int i) {
+ FileDescriptor fd = new FileDescriptor();
+ setfdVal(fd, i);
+ return fd;
+ }
+
+ static native boolean randomBytes(byte[] someBytes);
+
+ static native void initPipe(int[] fda, boolean blocking);
+
+ static native boolean drain(int fd) throws IOException;
+
+ static native void configureBlocking(FileDescriptor fd, boolean blocking)
+ throws IOException;
+
+ static native int fdVal(FileDescriptor fd);
+
+ static native void setfdVal(FileDescriptor fd, int value);
+
+ static native void initIDs();
+
+ static {
+ // Note that IOUtil.initIDs is called from within Util.load.
+ Util.load();
+ }
+
+}