diff options
| -rw-r--r-- | java/openjdk7/Makefile | 3 | ||||
| -rw-r--r-- | java/openjdk7/files/patch-zzz-nio-kqueue | 1236 |
2 files changed, 1239 insertions, 0 deletions
diff --git a/java/openjdk7/Makefile b/java/openjdk7/Makefile index ef7394cfcff5..5bfce842054d 100644 --- a/java/openjdk7/Makefile +++ b/java/openjdk7/Makefile @@ -7,6 +7,7 @@ PORTNAME= openjdk PORTVERSION= ${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_BUILD_NUMBER} +PORTREVISION= 1 CATEGORIES= java devel MASTER_SITES= http://download.java.net/openjdk/jdk7/promoted/b${JDK_BUILD_NUMBER}/ \ ${MASTER_SITE_APACHE:S,%SUBDIR%/,ant/binaries/:ant,} @@ -15,11 +16,13 @@ DISTFILES= ${JDK_SRC_DISTFILE}${EXTRACT_SUFX} \ MAINTAINER= glewis@FreeBSD.org COMMENT= Java Development Kit 7 + LICENSE= GPLv2 WRKSRC= ${WRKDIR}/${PORTNAME} USE_ZIP= YES +MAKE_JOBS_UNSAFE= YES JDK_MAJOR_VERSION= 7 JDK_MINOR_VERSION= 0 diff --git a/java/openjdk7/files/patch-zzz-nio-kqueue b/java/openjdk7/files/patch-zzz-nio-kqueue new file mode 100644 index 000000000000..61c4783237bb --- /dev/null +++ b/java/openjdk7/files/patch-zzz-nio-kqueue @@ -0,0 +1,1236 @@ +--- jdk/src/share/classes/sun/nio/ch/KqueueSelectorProvider.java (revision 0) ++++ jdk/src/share/classes/sun/nio/ch/KqueueSelectorProvider.java (revision 16) +@@ -0,0 +1,17 @@ ++package sun.nio.ch; ++ ++import java.io.IOException; ++import java.nio.channels.*; ++import java.nio.channels.spi.*; ++ ++public class KqueueSelectorProvider ++ extends SelectorProviderImpl ++{ ++ public AbstractSelector openSelector() throws IOException { ++ return new KqueueSelectorImpl(this); ++ } ++ ++ public Channel inheritedChannel() throws IOException { ++ return InheritedChannel.getChannel(); ++ } ++} +--- jdk/src/solaris/native/sun/nio/ch/KqueuePort.c (revision 0) ++++ jdk/src/solaris/native/sun/nio/ch/KqueuePort.c (revision 16) +@@ -0,0 +1,67 @@ ++/* ++ * Scratched by davidxu@freebsd.org ++ */ ++ ++#include "jni.h" ++#include "jni_util.h" ++#include "jvm.h" ++#include "jlong.h" ++#include "nio_util.h" ++ ++#include "sun_nio_ch_KqueuePort.h" ++ ++#include <unistd.h> ++#include <sys/types.h> ++#include <sys/socket.h> ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++JNIEXPORT void JNICALL ++Java_sun_nio_ch_KqueuePort_socketpair ++ (JNIEnv *env, jclass cls, jintArray sv) ++{ ++ int sp[2]; ++ if (socketpair(PF_UNIX, SOCK_STREAM, 0, sp) == -1) { ++ JNU_ThrowIOExceptionWithLastError(env, "socketpair failed"); ++ } else { ++ jint res[2]; ++ res[0] = (jint)sp[0]; ++ res[1] = (jint)sp[1]; ++ (*env)->SetIntArrayRegion(env, sv, 0, 2, &res[0]); ++ } ++} ++ ++JNIEXPORT void JNICALL Java_sun_nio_ch_KqueuePort_interrupt ++ (JNIEnv *env, jclass cls, jint fd) ++{ ++ int res; ++ int buf[1]; ++ buf[0] = 1; ++ RESTARTABLE(write(fd, buf, 1), res); ++ if (res < 0) { ++ JNU_ThrowIOExceptionWithLastError(env, "write failed"); ++ } ++} ++ ++JNIEXPORT void JNICALL Java_sun_nio_ch_KqueuePort_drain1 ++ (JNIEnv *env, jclass cls, jint fd) ++{ ++ int res; ++ char buf[1]; ++ RESTARTABLE(read(fd, buf, 1), res); ++ if (res < 0) { ++ JNU_ThrowIOExceptionWithLastError(env, "drain1 failed"); ++ } ++} ++ ++JNIEXPORT void JNICALL Java_sun_nio_ch_KqueuePort_close0 ++ (JNIEnv *env, jclass cls, jint fd) ++{ ++ int res; ++ RESTARTABLE(close(fd), res); ++} ++ ++#ifdef __cplusplus ++} ++#endif +--- jdk/src/solaris/native/sun/nio/ch/Kqueue.c (revision 0) ++++ jdk/src/solaris/native/sun/nio/ch/Kqueue.c (revision 16) +@@ -0,0 +1,174 @@ ++/* ++ * Scratched by davidxu@freebsd.org ++ */ ++ ++#include "jni.h" ++#include "jni_util.h" ++#include "jvm.h" ++#include "jlong.h" ++ ++#include "sun_nio_ch_Kqueue.h" ++ ++#include <errno.h> ++#include <sys/types.h> ++#include <sys/event.h> ++#include <sys/time.h> ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++static int ++restartable_kevent(int kqfd, struct kevent *changelist, int nchanges, ++ struct kevent *eventlist, int nevents); ++ ++static int ++timeout_kevent(int kqfd, struct kevent *changelist, int nchanges, ++ struct kevent *eventlist, int nevents, int timo); ++ ++JNIEXPORT jint JNICALL Java_sun_nio_ch_Kqueue_kqueue ++ (JNIEnv *env, jclass cls) ++{ ++ int kqfd = kqueue(); ++ if (kqfd < 0) { ++ JNU_ThrowIOExceptionWithLastError(env, "Error opening kqueue"); ++ return -1; ++ } ++ return kqfd; ++} ++ ++JNIEXPORT jint JNICALL Java_sun_nio_ch_Kqueue_keventChange ++ (JNIEnv *env, jclass cls, jint kqfd, jint fd, jshort flags, jshort filter) ++{ ++ struct kevent ev; ++ struct timespec ts; ++ ++ ev.ident = fd; ++ ev.flags = flags; ++ ev.filter = filter; ++ ev.fflags = 0; ++ ev.data = 0; ++ ev.udata = NULL; ++ ts.tv_sec = 0; ++ ts.tv_nsec = 0; ++ if (kevent(kqfd, &ev, 1, NULL, 0, &ts) < 0) ++ JNU_ThrowIOExceptionWithLastError(env, "Error changing kevent"); ++ return (0); ++} ++ ++JNIEXPORT jint JNICALL Java_sun_nio_ch_Kqueue_kevent ++ (JNIEnv *env, jclass cls, jint kqfd , jlong changelist_addr, jint nchanges, ++ jlong eventlist_addr, jint nevents, jlong timeout) ++{ ++ struct kevent *changelist = (struct kevent *)jlong_to_ptr(changelist_addr); ++ struct kevent *eventlist = (struct kevent *)jlong_to_ptr(eventlist_addr); ++ int result; ++ ++ if (timeout < 0) { ++ result = restartable_kevent(kqfd, changelist, nchanges, ++ eventlist, nevents); ++ } else { ++ result = timeout_kevent(kqfd, changelist, nchanges, eventlist, ++ nevents, timeout); ++ } ++ ++ if (result < 0) { ++ JNU_ThrowIOExceptionWithLastError(env, "Error reading driver"); ++ return -1; ++ } ++ return result; ++} ++ ++static int ++restartable_kevent(int kqfd, struct kevent *changelist, int nchanges, ++ struct kevent *eventlist, int nevents) ++{ ++ int result; ++ ++ for (;;) { ++ result = kevent(kqfd, changelist, nchanges, eventlist, ++ nevents, NULL); ++ if (result == -1 && errno == EINTR) { ++ continue; ++ } else { ++ return result; ++ } ++ } ++} ++ ++static int ++timeout_kevent(int kqfd, struct kevent *changelist, int nchanges, ++ struct kevent *eventlist, int nevents, int timo) ++{ ++ struct timeval timeout, now, end; ++ int result; ++ ++ timeout.tv_sec = timo / 1000; ++ timeout.tv_usec = (timo % 1000) * 1000; ++ gettimeofday(&now, NULL); ++ timeradd(&now, &timeout, &end); ++ ++ for (;;) { ++ struct timespec ts; ++ ++ ts.tv_sec = timeout.tv_sec; ++ ts.tv_nsec = timeout.tv_usec * 1000; ++ result = kevent(kqfd, changelist, nchanges, eventlist, nevents, ++ &ts); ++ if (result == -1 && (errno == EINTR)) { ++ gettimeofday(&now, NULL); ++ if (timercmp(&now, &end, >=)) ++ return 0; ++ timersub(&end, &now, &timeout); ++ } else { ++ return result; ++ } ++ } ++} ++ ++JNIEXPORT jint JNICALL Java_sun_nio_ch_Kqueue_keventSize ++ (JNIEnv *env, jclass cls) ++{ ++ return sizeof(struct kevent); ++} ++ ++JNIEXPORT void JNICALL Java_sun_nio_ch_Kqueue_putKevent ++ (JNIEnv *env, jclass cls, jlong address, jint index, jint fd, jshort flags, jshort filter) ++{ ++ struct kevent *ev = (struct kevent *)jlong_to_ptr(address); ++ ++ ev[index].ident = fd; ++ ev[index].flags = flags; ++ ev[index].filter = filter; ++ ev[index].fflags = 0; ++ ev[index].data = 0; ++ ev[index].udata = NULL; ++} ++ ++JNIEXPORT jshort JNICALL Java_sun_nio_ch_Kqueue_getKeventFilter ++ (JNIEnv *env, jclass cls, jlong address, jint index) ++{ ++ struct kevent *ev = (struct kevent *)jlong_to_ptr(address); ++ ++ return ev[index].filter; ++} ++ ++JNIEXPORT jshort JNICALL Java_sun_nio_ch_Kqueue_getKeventFlags ++ (JNIEnv *env, jclass cls, jlong address, jint index) ++{ ++ struct kevent *ev = (struct kevent *)jlong_to_ptr(address); ++ ++ return ev[index].flags; ++} ++ ++JNIEXPORT jint JNICALL Java_sun_nio_ch_Kqueue_getKeventIdent ++ (JNIEnv *env, jclass cls, jlong address, jint index) ++{ ++ struct kevent *ev = (struct kevent *)jlong_to_ptr(address); ++ ++ return (int)ev[index].ident; ++} ++ ++#ifdef __cplusplus ++} ++#endif +--- jdk/src/solaris/native/sun/nio/ch/KqueueArrayWrapper.c (revision 0) ++++ jdk/src/solaris/native/sun/nio/ch/KqueueArrayWrapper.c (revision 16) +@@ -0,0 +1,30 @@ ++/* ++ * Scratched by davidxu@freebsd.org ++ */ ++ ++#include "jni.h" ++#include "jni_util.h" ++#include "jvm.h" ++#include "jlong.h" ++#include "nio_util.h" ++ ++#include "sun_nio_ch_KqueueArrayWrapper.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++JNIEXPORT void JNICALL Java_sun_nio_ch_KqueueArrayWrapper_interrupt ++ (JNIEnv *env, jclass cls, jint fd) ++{ ++ int fakebuf[1]; ++ fakebuf[0] = 1; ++ if (write(fd, fakebuf, 1) < 0) { ++ JNU_ThrowIOExceptionWithLastError(env, ++ "Write to interrupt fd failed"); ++ } ++} ++ ++#ifdef __cplusplus ++} ++#endif +--- jdk/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java (revision 1) ++++ jdk/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java (revision 16) +@@ -47,6 +47,10 @@ + public static SelectorProvider create() { + String osname = AccessController.doPrivileged( + new GetPropertyAction("os.name")); ++ if ("FreeBSD".equals(osname)) { ++ return new sun.nio.ch.KqueueSelectorProvider(); ++ } ++ + if ("SunOS".equals(osname)) { + return new sun.nio.ch.DevPollSelectorProvider(); + } +--- jdk/src/solaris/classes/sun/nio/ch/KqueueSelectorImpl.java (revision 0) ++++ jdk/src/solaris/classes/sun/nio/ch/KqueueSelectorImpl.java (revision 16) +@@ -0,0 +1,204 @@ ++/* ++ * scratched by davidxu@freebsd.org ++ */ ++ ++package sun.nio.ch; ++ ++import java.io.IOException; ++import java.nio.channels.*; ++import java.nio.channels.spi.*; ++import java.util.*; ++import sun.misc.*; ++ ++ ++/** ++ * An implementation of Selector for FreeBSD. ++ */ ++class KqueueSelectorImpl ++ extends SelectorImpl ++{ ++ ++ // File descriptors used for interrupt ++ protected int fd0; ++ protected int fd1; ++ ++ // The kqueue object ++ KqueueArrayWrapper kqueueWrapper; ++ ++ // The number of valid channels in this Selector's poll array ++ private int totalChannels; ++ ++ // Maps from file descriptors to keys ++ private HashMap fdToKey; ++ ++ // True if this Selector has been closed ++ private boolean closed = false; ++ ++ // Lock for interrupt triggering and clearing ++ private Object interruptLock = new Object(); ++ private boolean interruptTriggered = false; ++ ++ private BitSet updatedSet; ++ ++ /** ++ * Package private constructor called by factory method in ++ * the abstract superclass Selector. ++ */ ++ KqueueSelectorImpl(SelectorProvider sp) { ++ super(sp); ++ int[] fdes = new int[2]; ++ IOUtil.initPipe(fdes, false); ++ fd0 = fdes[0]; ++ fd1 = fdes[1]; ++ kqueueWrapper = new KqueueArrayWrapper(); ++ totalChannels = 1; ++ kqueueWrapper.initInterrupt(fd0, fd1); ++ updatedSet = new BitSet(); ++ fdToKey = new HashMap(); ++ } ++ ++ protected int doSelect(long timeout) ++ throws IOException ++ { ++ if (closed) ++ throw new ClosedSelectorException(); ++ processDeregisterQueue(); ++ try { ++ begin(); ++ kqueueWrapper.poll(timeout); ++ } finally { ++ end(); ++ } ++ processDeregisterQueue(); ++ int numKeysUpdated = updateSelectedKeys(); ++ if (kqueueWrapper.interrupted()) { ++ // Clear the wakeup pipe ++ synchronized (interruptLock) { ++ kqueueWrapper.clearInterrupted(); ++ IOUtil.drain(fd0); ++ interruptTriggered = false; ++ } ++ } ++ return numKeysUpdated; ++ } ++ ++ /** ++ * Update the keys whose fd's have been selected by the kqueue. ++ * Add the ready keys to the ready queue. ++ */ ++ private int updateSelectedKeys() { ++ int entries = kqueueWrapper.updated; ++ int numKeysUpdated = 0; ++ SelectionKeyImpl ski; ++ int fd; ++ int i; ++ ++ updatedSet.clear(); ++ for (i = 0; i < entries; i++) { ++ fd = kqueueWrapper.getDescriptor(i); ++ ski = (SelectionKeyImpl) fdToKey.get(new Integer(fd)); ++ // ski is null in the case of an interrupt ++ if (ski != null) ++ ski.nioReadyOps(0); ++ } ++ ++ for (i = 0; i < entries; i++) { ++ fd = kqueueWrapper.getDescriptor(i); ++ ski = (SelectionKeyImpl) fdToKey.get(new Integer(fd)); ++ // ski is null in the case of an interrupt ++ if (ski != null) { ++ int rOps = kqueueWrapper.getReventOps(i); ++ if (selectedKeys.contains(ski)) { ++ if (ski.channel.translateAndUpdateReadyOps(rOps, ski)) { ++ if (!updatedSet.get(fd)) { ++ updatedSet.set(fd); ++ numKeysUpdated++; ++ } ++ } ++ } else { ++ ski.channel.translateAndSetReadyOps(rOps, ski); ++ if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) { ++ selectedKeys.add(ski); ++ if (!updatedSet.get(fd)) { ++ updatedSet.set(fd); ++ numKeysUpdated++; ++ } ++ } ++ } ++ } ++ } ++ return numKeysUpdated; ++ } ++ ++ protected void implClose() throws IOException { ++ if (!closed) { ++ closed = true; ++ FileDispatcherImpl.closeIntFD(fd0); ++ FileDispatcherImpl.closeIntFD(fd1); ++ if (kqueueWrapper != null) { ++ kqueueWrapper.release(fd0); ++ kqueueWrapper.closeKqueueFD(); ++ kqueueWrapper = null; ++ selectedKeys = null; ++ ++ // Deregister channels ++ Iterator i = keys.iterator(); ++ while (i.hasNext()) { ++ SelectionKeyImpl ski = (SelectionKeyImpl)i.next(); ++ deregister(ski); ++ SelectableChannel selch = ski.channel(); ++ if (!selch.isOpen() && !selch.isRegistered()) ++ ((SelChImpl)selch).kill(); ++ i.remove(); ++ } ++ totalChannels = 0; ++ ++ } ++ fd0 = -1; ++ fd1 = -1; ++ } ++ } ++ ++ protected void implRegister(SelectionKeyImpl ski) { ++ int fd = IOUtil.fdVal(ski.channel.getFD()); ++ fdToKey.put(new Integer(fd), ski); ++ totalChannels++; ++ keys.add(ski); ++ } ++ ++ protected void implDereg(SelectionKeyImpl ski) throws IOException { ++ int i = ski.getIndex(); ++ assert (i >= 0); ++ int fd = ski.channel.getFDVal(); ++ fdToKey.remove(new Integer(fd)); ++ kqueueWrapper.release(fd); ++ totalChannels--; ++ ski.setIndex(-1); ++ keys.remove(ski); ++ selectedKeys.remove(ski); ++ deregister((AbstractSelectionKey)ski); ++ SelectableChannel selch = ski.channel(); ++ if (!selch.isOpen() && !selch.isRegistered()) ++ ((SelChImpl)selch).kill(); ++ } ++ ++ void putEventOps(SelectionKeyImpl sk, int ops) { ++ int fd = IOUtil.fdVal(sk.channel.getFD()); ++ kqueueWrapper.setInterest(fd, ops); ++ } ++ ++ public Selector wakeup() { ++ synchronized (interruptLock) { ++ if (!interruptTriggered) { ++ kqueueWrapper.interrupt(); ++ interruptTriggered = true; ++ } ++ } ++ return this; ++ } ++ ++ static { ++ Util.load(); ++ } ++ ++} +--- jdk/src/solaris/classes/sun/nio/ch/Kqueue.java (revision 0) ++++ jdk/src/solaris/classes/sun/nio/ch/Kqueue.java (revision 16) +@@ -0,0 +1,49 @@ ++/* ++ * Scratched by davidxu@freebsd.org ++ */ ++ ++package sun.nio.ch; ++ ++import java.io.IOException; ++import sun.misc.Unsafe; ++ ++class Kqueue { ++ // Kevent filters ++ static final short EVFILT_READ = -1; ++ static final short EVFILT_WRITE = -2; ++ ++ // Kevent flags ++ static final short EV_ADD = 0x0001; ++ static final short EV_DELETE = 0x0002; ++ static final short EV_ONESHOT = 0x0010; ++ static final short EV_ERROR = 0x4000; ++ ++ private static final Unsafe unsafe = Unsafe.getUnsafe(); ++ static final int SIZEOF_KEVENT = keventSize(); ++ ++ private Kqueue() {} ++ ++ /** ++ * Allocates a poll array to handle up to {@code count} events. ++ */ ++ static long allocatePollArray(int count) { ++ return unsafe.allocateMemory(count * SIZEOF_KEVENT); ++ } ++ ++ /** ++ * Free a poll array ++ */ ++ static void freePollArray(long address) { ++ unsafe.freeMemory(address); ++ } ++ ++ static native int kqueue(); ++ static native int keventChange(int kqfd, int fd, short flags, short filter); ++ static native int kevent(int kqfd, long changeList, int nchanges, long eventList, ++ int nevents, long timeout); ++ static native int keventSize(); ++ static native void putKevent(long address, int index, int fd, short flag, short filter); ++ static native short getKeventFilter(long address, int index); ++ static native short getKeventFlags(long address, int index); ++ static native int getKeventIdent(long address, int index); ++} +--- jdk/src/solaris/classes/sun/nio/ch/KqueueArrayWrapper.java (revision 0) ++++ jdk/src/solaris/classes/sun/nio/ch/KqueueArrayWrapper.java (revision 16) +@@ -0,0 +1,211 @@ ++/* ++ * Scratched by davidxu@freebsd.org ++ */ ++ ++package sun.nio.ch; ++ ++import sun.misc.*; ++import java.io.IOException; ++import java.util.HashMap; ++import java.util.Set; ++import java.util.Arrays; ++import static sun.nio.ch.Kqueue.*; ++ ++class KqueueArrayWrapper { ++ ++ // Event masks copied from class AbstractPollArrayWrapper ++ static final short POLLIN = 0x0001; ++ static final short POLLOUT = 0x0004; ++ static final short POLLERR = 0x0008; ++ static final short POLLHUP = 0x0010; ++ static final short POLLNVAL = 0x0020; ++ static final short POLLREMOVE = 0x0800; ++ ++ // Zero mask to unregister events from kqueue ++ static final Integer ZERO_MASK = new Integer(0); ++ ++ // Capacity increment of some arrays ++ static final int capacityIncr = 100; ++ ++ KqueueArrayWrapper() { ++ int allocationSize; ++ ++ // initial size of event array ++ pollKeventSize = capacityIncr * 2; ++ allocationSize = pollKeventSize * SIZEOF_KEVENT; ++ pollKeventArray = new AllocatedNativeObject(allocationSize, true); ++ kqfd = kqueue(); ++ } ++ ++ // Machinery for remembering fd registration changes ++ private HashMap<Integer, Integer> updateMap = new HashMap<Integer, Integer>(); ++ private int[] oldMasks = new int[capacityIncr]; ++ ++ // kevent array to receive ++ private AllocatedNativeObject pollKeventArray; ++ ++ // current size of pollKeventArray ++ int pollKeventSize; ++ ++ // the pollKeventSize should be larger than this ++ int nextKeventSize; ++ ++ // The fd of the kqueue() ++ int kqfd; ++ ++ // The fd of the interrupt line going out ++ int outgoingInterruptFD; ++ ++ // The fd of the interrupt line coming in ++ int incomingInterruptFD; ++ ++ // The index of the interrupt FD ++ int interruptedIndex; ++ ++ // Number of updated kevent entries ++ int updated; ++ ++ // ensure some array sizes are large enough with a given file handle ++ void ensureFd(int fd) { ++ ensureNextEventFd(fd); ++ if (oldMasks.length < fd+1) ++ oldMasks = Arrays.copyOf(oldMasks, fd+capacityIncr); ++ } ++ ++ void ensureNextEventFd(int fd) { ++ // each file handle may have two filters, read and write. ++ if (nextKeventSize / 2 < fd+1) ++ nextKeventSize = (fd+1) * 2; ++ } ++ ++ void resizeEventBuffer() { ++ if (nextKeventSize > pollKeventSize) { ++ pollKeventArray.free(); ++ pollKeventSize = nextKeventSize + capacityIncr * 2; ++ int allocationSize = pollKeventSize * SIZEOF_KEVENT; ++ pollKeventArray = new AllocatedNativeObject(allocationSize, true); ++ } ++ } ++ ++ void initInterrupt(int fd0, int fd1) { ++ outgoingInterruptFD = fd1; ++ incomingInterruptFD = fd0; ++ ensureFd(fd0); ++ keventChange(kqfd, fd0, EV_ADD, EVFILT_READ); ++ } ++ ++ int getReventOps(int i) { ++ short filter = getKeventFilter(pollKeventArray.address(), i); ++ short flags = getKeventFlags(pollKeventArray.address(), i); ++ if ((flags & EV_ERROR) != 0) ++ return POLLERR; ++ if (filter == EVFILT_READ) ++ return POLLIN; ++ if (filter == EVFILT_WRITE) ++ return POLLOUT; ++ return (0); ++ } ++ ++ int getDescriptor(int i) { ++ return getKeventIdent(pollKeventArray.address(), i); ++ } ++ ++ void setInterest(int fd, int mask) { ++ if (fd <0) ++ throw new IllegalArgumentException("file handle less than 0"); ++ synchronized (updateMap) { ++ ensureFd(fd); ++ updateMap.put(new Integer(fd), new Integer(mask)); ++ } ++ } ++ ++ void release(int fd) { ++ synchronized (updateMap) { ++ updateMap.put(new Integer(fd), ZERO_MASK); ++ } ++ } ++ ++ void closeKqueueFD() throws IOException { ++ FileDispatcherImpl.closeIntFD(kqfd); ++ pollKeventArray.free(); ++ } ++ ++ int poll(long timeout) { ++ int changeCount = updateRegistrations(); ++ updated = kevent(kqfd, pollKeventArray.address(), changeCount, ++ pollKeventArray.address(), pollKeventSize, timeout); ++ for (int i = 0; i < updated; i++) { ++ if (getDescriptor(i) == incomingInterruptFD) { ++ interruptedIndex = i; ++ interrupted = true; ++ break; ++ } ++ } ++ return updated; ++ } ++ ++ int updateRegistrations() { ++ int index = 0; ++ synchronized (updateMap) { ++ resizeEventBuffer(); ++ ++ Set<Integer> s = updateMap.keySet(); ++ /* ++ * Because resizeEventBuffer may reallocate event buffer, ++ * we must retrieve fresh address here. ++ */ ++ long address = pollKeventArray.address(); ++ ++ for (Integer fd : s) { ++ Integer newmask = updateMap.get(fd); ++ int oldmask = oldMasks[fd]; ++ if ((oldmask & POLLIN) != 0) { ++ if ((newmask & POLLIN) == 0) { ++ putKevent(address, index, fd.intValue(), EV_DELETE, EVFILT_READ); ++ index++; ++ } ++ } else { ++ if ((newmask & POLLIN) != 0) { ++ putKevent(address, index, fd.intValue(), EV_ADD, EVFILT_READ); ++ index++; ++ } ++ } ++ ++ if ((oldmask & POLLOUT) != 0) { ++ if ((newmask & POLLOUT) == 0) { ++ putKevent(address, index, fd.intValue(), EV_DELETE, EVFILT_WRITE); ++ index++; ++ } ++ } else { ++ if ((newmask & POLLOUT) != 0) { ++ putKevent(address, index, fd.intValue(), EV_ADD, EVFILT_WRITE); ++ index++; ++ } ++ } ++ oldMasks[fd] = newmask; ++ } ++ updateMap.clear(); ++ } ++ return index; ++ } ++ ++ boolean interrupted = false; ++ ++ public void interrupt() { ++ interrupt(outgoingInterruptFD); ++ } ++ ++ public int interruptedIndex() { ++ return interruptedIndex; ++ } ++ ++ boolean interrupted() { ++ return interrupted; ++ } ++ ++ void clearInterrupted() { ++ interrupted = false; ++ } ++ ++ private static native void interrupt(int fd); ++} +--- jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java (revision 1) ++++ jdk/src/solaris/classes/sun/nio/ch/DefaultAsynchronousChannelProvider.java (revision 16) +@@ -46,6 +46,8 @@ + public static AsynchronousChannelProvider create() { + String osname = AccessController + .doPrivileged(new GetPropertyAction("os.name")); ++ if (osname.equals("FreeBSD")) ++ return new FreeBSDAsynchronousChannelProvider(); + if (osname.equals("SunOS")) + return new SolarisAsynchronousChannelProvider(); + if (osname.equals("Linux")) +--- jdk/src/solaris/classes/sun/nio/ch/KqueuePort.java (revision 0) ++++ jdk/src/solaris/classes/sun/nio/ch/KqueuePort.java (revision 16) +@@ -0,0 +1,321 @@ ++/* ++ * Scratched by davidxu@FreeBSD.org ++ */ ++ ++package sun.nio.ch; ++ ++import java.nio.channels.spi.AsynchronousChannelProvider; ++import java.io.IOException; ++import java.util.concurrent.ArrayBlockingQueue; ++import java.util.concurrent.RejectedExecutionException; ++import java.util.concurrent.atomic.AtomicInteger; ++import static sun.nio.ch.Kqueue.*; ++ ++/** ++ * AsynchronousChannelGroup implementation based on the FreeBSD kqueue facility. ++ */ ++ ++final class KqueuePort ++ extends Port ++{ ++/* ++ // Kevent filters ++ static final short EVFILT_READ = -1; ++ static final short EVFILT_WRITE = -2; ++ ++ // Kevent flags ++ static final char EV_ADD = 0x0001; ++ static final char EV_DELETE = 0x0002; ++ static final char EV_EOF = 0x8000; ++ static final char EV_ERROR = 0x4000; ++*/ ++ ++ // maximum number of events to poll at a time ++ private static final int MAX_KEVENTS = 512; ++ ++ // kqueue file descriptor ++ private final int kqfd; ++ ++ // true if kqueue closed ++ private boolean closed; ++ ++ // socket pair used for wakeup ++ private final int sp[]; ++ ++ // number of wakeups pending ++ private final AtomicInteger wakeupCount = new AtomicInteger(); ++ ++ // address of the poll array passed to kevent() ++ private final long address; ++ ++ // encapsulates an event for a channel ++ static class Event { ++ final PollableChannel channel; ++ final int events; ++ ++ Event(PollableChannel channel, int events) { ++ this.channel = channel; ++ this.events = events; ++ } ++ ++ PollableChannel channel() { return channel; } ++ int events() { return events; } ++ } ++ ++ // queue of events for cases that a polling thread dequeues more than one ++ // event ++ private final ArrayBlockingQueue<Event> queue; ++ private final Event NEED_TO_POLL = new Event(null, 0); ++ private final Event EXECUTE_TASK_OR_SHUTDOWN = new Event(null, 0); ++ ++ KqueuePort(AsynchronousChannelProvider provider, ThreadPool pool) ++ throws IOException ++ { ++ super(provider, pool); ++ ++ // open kqueue ++ this.kqfd = kqueue(); ++ ++ // create socket pair for wakeup mechanism ++ int[] sv = new int[2]; ++ try { ++ socketpair(sv); ++ // register one end with epoll ++ keventChange(kqfd, sv[0], EV_ADD, EVFILT_READ); ++ } catch (IOException x) { ++ close0(kqfd); ++ throw x; ++ } ++ this.sp = sv; ++ ++ // allocate the poll array ++ this.address = allocatePollArray(MAX_KEVENTS); ++ ++ // create the queue and offer the special event to ensure that the first ++ // threads polls ++ this.queue = new ArrayBlockingQueue<Event>(MAX_KEVENTS); ++ this.queue.offer(NEED_TO_POLL); ++ } ++ ++ KqueuePort start() { ++ startThreads(new EventHandlerTask()); ++ return this; ++ } ++ ++ /** ++ * Release all resources ++ */ ++ private void implClose() { ++ synchronized (this) { ++ if (closed) ++ return; ++ closed = true; ++ } ++ freePollArray(address); ++ close0(sp[0]); ++ close0(sp[1]); ++ close0(kqfd); ++ } ++ ++ private void wakeup() { ++ if (wakeupCount.incrementAndGet() == 1) { ++ // write byte to socketpair to force wakeup ++ try { ++ interrupt(sp[1]); ++ } catch (IOException x) { ++ throw new AssertionError(x); ++ } ++ } ++ } ++ ++ @Override ++ void executeOnHandlerTask(Runnable task) { ++ synchronized (this) { ++ if (closed) ++ throw new RejectedExecutionException(); ++ offerTask(task); ++ wakeup(); ++ } ++ } ++ ++ @Override ++ void shutdownHandlerTasks() { ++ /* ++ * If no tasks are running then just release resources; otherwise ++ * write to the one end of the socketpair to wakeup any polling threads. ++ */ ++ int nThreads = threadCount(); ++ if (nThreads == 0) { ++ implClose(); ++ } else { ++ // send interrupt to each thread ++ while (nThreads-- > 0) { ++ wakeup(); ++ } ++ } ++ } ++ ++ // invoke by clients to register a file descriptor ++ @Override ++ void startPoll(int fd, int events) { ++ ++ if ((events & POLLIN) != 0) ++ keventChange(kqfd, fd, (short)(EV_ONESHOT|EV_ADD), EVFILT_READ); ++ if ((events & POLLOUT) != 0) ++ keventChange(kqfd, fd, (short)(EV_ONESHOT|EV_ADD), EVFILT_WRITE); ++ } ++ ++ /* ++ * Task to process events from kevent and dispatch to the channel's ++ * onEvent handler. ++ * ++ * Events are retreived from kevent in batch and offered to a BlockingQueue ++ * where they are consumed by handler threads. A special "NEED_TO_POLL" ++ * event is used to signal one consumer to re-poll when all events have ++ * been consumed. ++ */ ++ private class EventHandlerTask implements Runnable { ++ private Event poll() throws IOException { ++ try { ++ for (;;) { ++ int n = kevent(kqfd, 0, 0, address, MAX_KEVENTS, -1); ++ /* ++ * 'n' events have been read. Here we map them to their ++ * corresponding channel in batch and queue n-1 so that ++ * they can be handled by other handler threads. The last ++ * event is handled by this thread (and so is not queued). ++ */ ++ fdToChannelLock.readLock().lock(); ++ try { ++ while (n-- > 0) { ++ int fd = getKeventIdent(address, n); ++ ++ // wakeup ++ if (fd == sp[0]) { ++ if (wakeupCount.decrementAndGet() == 0) { ++ // no more wakeups so drain pipe ++ drain1(sp[0]); ++ } ++ ++ // queue special event if there are more events ++ // to handle. ++ if (n > 0) { ++ queue.offer(EXECUTE_TASK_OR_SHUTDOWN); ++ continue; ++ } ++ return EXECUTE_TASK_OR_SHUTDOWN; ++ } ++ ++ PollableChannel channel = fdToChannel.get(fd); ++ if (channel != null) { ++ int events = getEvents(address, n); ++ Event ev = new Event(channel, events); ++ ++ // n-1 events are queued; This thread handles ++ // the last one except for the wakeup ++ if (n > 0) { ++ queue.offer(ev); ++ } else { ++ return ev; ++ } ++ } ++ } ++ } finally { ++ fdToChannelLock.readLock().unlock(); ++ } ++ } ++ } finally { ++ // to ensure that some thread will poll when all events have ++ // been consumed ++ queue.offer(NEED_TO_POLL); ++ } ++ } ++ ++ public void run() { ++ Invoker.GroupAndInvokeCount myGroupAndInvokeCount = ++ Invoker.getGroupAndInvokeCount(); ++ final boolean isPooledThread = (myGroupAndInvokeCount != null); ++ boolean replaceMe = false; ++ Event ev; ++ try { ++ for (;;) { ++ // reset invoke count ++ if (isPooledThread) ++ myGroupAndInvokeCount.resetInvokeCount(); ++ ++ try { ++ replaceMe = false; ++ ev = queue.take(); ++ ++ // no events and this thread has been "selected" to ++ // poll for more. ++ if (ev == NEED_TO_POLL) { ++ try { ++ ev = poll(); ++ } catch (IOException x) { ++ x.printStackTrace(); ++ return; ++ } ++ } ++ } catch (InterruptedException x) { ++ continue; ++ } ++ ++ // handle wakeup to execute task or shutdown ++ if (ev == EXECUTE_TASK_OR_SHUTDOWN) { ++ Runnable task = pollTask(); ++ if (task == null) { ++ // shutdown request ++ return; ++ } ++ // run task (may throw error/exception) ++ replaceMe = true; ++ task.run(); ++ continue; ++ } ++ ++ // process event ++ try { ++ ev.channel().onEvent(ev.events(), isPooledThread); ++ } catch (Error x) { ++ replaceMe = true; throw x; ++ } catch (RuntimeException x) { ++ replaceMe = true; throw x; ++ } ++ } ++ } finally { ++ // last handler to exit when shutdown releases resources ++ int remaining = threadExit(this, replaceMe); ++ if (remaining == 0 && isShutdown()) { ++ implClose(); ++ } ++ } ++ } ++ } ++ ++ static int getEvents(long address, int index) { ++ short filter = getKeventFilter(address, index); ++ short flags = getKeventFlags(address, index); ++ if ((flags & EV_ERROR) != 0) ++ return POLLERR; ++ if (filter == EVFILT_READ) ++ return POLLIN; ++ if (filter == EVFILT_WRITE) ++ return POLLOUT; ++ return (0); ++ } ++ ++ // -- Native methods -- ++ ++ private static native void socketpair(int[] sv) throws IOException; ++ ++ private static native void interrupt(int fd) throws IOException; ++ ++ private static native void drain1(int fd) throws IOException; ++ ++ private static native void close0(int fd); ++ ++ static { ++ Util.load(); ++ } ++} +--- jdk/src/solaris/classes/sun/nio/ch/FreeBSDAsynchronousChannelProvider.java (revision 0) ++++ jdk/src/solaris/classes/sun/nio/ch/FreeBSDAsynchronousChannelProvider.java (revision 16) +@@ -0,0 +1,75 @@ ++ ++package sun.nio.ch; ++ ++import java.nio.channels.*; ++import java.nio.channels.spi.AsynchronousChannelProvider; ++import java.util.concurrent.ExecutorService; ++import java.util.concurrent.ThreadFactory; ++import java.net.ProtocolFamily; ++import java.io.IOException; ++ ++public class FreeBSDAsynchronousChannelProvider ++ extends AsynchronousChannelProvider ++{ ++ private static volatile KqueuePort defaultPort; ++ ++ private KqueuePort defaultEventPort() throws IOException { ++ if (defaultPort == null) { ++ synchronized (FreeBSDAsynchronousChannelProvider.class) { ++ if (defaultPort == null) { ++ defaultPort = new KqueuePort(this, ThreadPool.getDefault()).start(); ++ } ++ } ++ } ++ return defaultPort; ++ } ++ ++ public FreeBSDAsynchronousChannelProvider() { ++ } ++ ++ @Override ++ public AsynchronousChannelGroup openAsynchronousChannelGroup(int nThreads, ThreadFactory factory) ++ throws IOException ++ { ++ return new KqueuePort(this, ThreadPool.create(nThreads, factory)).start(); ++ } ++ ++ @Override ++ public AsynchronousChannelGroup openAsynchronousChannelGroup(ExecutorService executor, int initialSize) ++ throws IOException ++ { ++ return new KqueuePort(this, ThreadPool.wrap(executor, initialSize)).start(); ++ } ++ ++ private Port toPort(AsynchronousChannelGroup group) throws IOException { ++ if (group == null) { ++ return defaultEventPort(); ++ } else { ++ if (!(group instanceof KqueuePort)) ++ throw new IllegalChannelGroupException(); ++ return (Port)group; ++ } ++ } ++ ++ @Override ++ public AsynchronousServerSocketChannel openAsynchronousServerSocketChannel(AsynchronousChannelGroup group) ++ throws IOException ++ { ++ return new UnixAsynchronousServerSocketChannelImpl(toPort(group)); ++ } ++ ++ @Override ++ public AsynchronousSocketChannel openAsynchronousSocketChannel(AsynchronousChannelGroup group) ++ throws IOException ++ { ++ return new UnixAsynchronousSocketChannelImpl(toPort(group)); ++ } ++ ++ @Override ++ public AsynchronousDatagramChannel openAsynchronousDatagramChannel(ProtocolFamily family, ++ AsynchronousChannelGroup group) ++ throws IOException ++ { ++ return new SimpleAsynchronousDatagramChannelImpl(family, toPort(group)); ++ } ++} +$FreeBSD$ + +--- jdk/make/java/nio/Makefile (revision 1) ++++ jdk/make/java/nio/Makefile (revision 16) +@@ -264,7 +264,12 @@ + ifeq ($(PLATFORM), bsd) + FILES_java += \ + sun/nio/ch/AbstractPollSelectorImpl.java \ ++ sun/nio/ch/FreeBSDAsynchronousChannelProvider.java \ + sun/nio/ch/InheritedChannel.java \ ++ sun/nio/ch/Kqueue.java \ ++ sun/nio/ch/KqueueArrayWrapper.java \ ++ sun/nio/ch/KqueueSelectorProvider.java \ ++ sun/nio/ch/KqueueSelectorImpl.java \ + sun/nio/ch/PollSelectorProvider.java \ + sun/nio/ch/PollSelectorImpl.java \ + sun/nio/ch/Port.java \ +@@ -299,6 +304,9 @@ + + FILES_c += \ + InheritedChannel.c \ ++ Kqueue.c \ ++ KqueueArrayWrapper.c \ ++ KqueuePort.c \ + NativeThread.c \ + PollArrayWrapper.c \ + UnixAsynchronousServerSocketChannelImpl.c \ +@@ -311,6 +319,9 @@ + + FILES_export += \ + sun/nio/ch/InheritedChannel.java \ ++ sun/nio/ch/Kqueue.java \ ++ sun/nio/ch/KqueueArrayWrapper.java \ ++ sun/nio/ch/KqueuePort.java \ + sun/nio/ch/NativeThread.java \ + sun/nio/ch/UnixAsynchronousServerSocketChannelImpl.java \ + sun/nio/ch/UnixAsynchronousSocketChannelImpl.java \ |