Thread: [Jnode-svn-commits] SF.net SVN: jnode: [2907] trunk/core/src/classpath/gnu/gnu/java/nio

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 2907
          http://jnode.svn.sourceforge.net/jnode/?rev=2907&view=rev
Author:   hagar-wize
Date:     2006-12-14 01:24:37 -0800 (Thu, 14 Dec 2006)

Log Message:
-----------
Classpath patches

Modified Paths:
--------------
    trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelSelectionKey.java
    trunk/core/src/classpath/gnu/gnu/java/nio/FileLockImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/NIOSocket.java

Added Paths:
-----------
    trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectionKeyImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectorImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/KqueueSelectionKeyImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/KqueueSelectorImpl.java
    trunk/core/src/classpath/gnu/gnu/java/nio/NIOSocketImpl.java

Modified: trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelImpl.java
===================================================================

--- trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelImpl.java	2006-12-13 19:25:39 UTC (rev 2906)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelImpl.java	2006-12-14 09:24:37 UTC (rev 2907)
@@ -55,8 +55,10 @@
  * @author Michael Koch
  */
 public final class DatagramChannelImpl extends DatagramChannel
+  implements VMChannelOwner
 {
   private NIODatagramSocket socket;
+  private VMChannel channel;
   
   /**
    * Indicates whether this channel initiated whatever operation
@@ -64,6 +66,16 @@
    */
   private boolean inChannelOperation;
 
+  protected DatagramChannelImpl (SelectorProvider provider)
+    throws IOException
+  {
+    super (provider);
+    socket = new NIODatagramSocket (new PlainDatagramSocketImpl(), this);
+    channel = new VMChannel();
+    channel.initSocket(false);
+    configureBlocking(true);
+  }
+
   /**
    * Indicates whether our datagram socket should ignore whether
    * we are set to non-blocking mode. Certain operations on our
@@ -85,14 +97,6 @@
     inChannelOperation = b;
   }
  
-  protected DatagramChannelImpl (SelectorProvider provider)
-    throws IOException
-  {
-    super (provider);
-    socket = new NIODatagramSocket (new PlainDatagramSocketImpl(), this);
-    configureBlocking(true);
-  }
-
   public DatagramSocket socket ()
   {
     return socket;
@@ -101,13 +105,13 @@
   protected void implCloseSelectableChannel ()
     throws IOException
   {
-    socket.close ();
+    channel.close();
   }
     
   protected void implConfigureBlocking (boolean blocking)
     throws IOException
   {
-    socket.setSoTimeout (blocking ? 0 : NIOConstants.DEFAULT_TIMEOUT);
+    channel.setBlocking(blocking);
   }
 
   public DatagramChannel connect (SocketAddress remote)
@@ -116,29 +120,43 @@
     if (!isOpen())
       throw new ClosedChannelException();
     
-    socket.connect (remote);
+    try
+      {
+        channel.connect((InetSocketAddress) remote, 0);
+      }
+    catch (ClassCastException cce)
+      {
+        throw new IOException("unsupported socked address type");
+      }
     return this;
   }
     
   public DatagramChannel disconnect ()
     throws IOException
   {
-    socket.disconnect ();
+    channel.disconnect();
     return this;
   }
     
-  public boolean isConnected ()
+  public boolean isConnected()
   {
-    return socket.isConnected ();
+    try
+      {
+        return channel.getPeerAddress() != null;
+      }
+    catch (IOException ioe)
+      {
+        return false;
+      }
   }
-
+    
   public int write (ByteBuffer src)
     throws IOException
   {
     if (!isConnected ())
       throw new NotYetConnectedException ();
     
-    return send (src, socket.getRemoteSocketAddress());
+    return channel.write(src);
   }
 
   public long write (ByteBuffer[] srcs, int offset, int length)
@@ -152,13 +170,11 @@
         || (length < 0)
         || (length > (srcs.length - offset)))
       throw new IndexOutOfBoundsException();
-      
-    long result = 0;
 
-    for (int index = offset; index < offset + length; index++)
-      result += write (srcs [index]);
-
-    return result;
+    /* We are connected, meaning we will write these bytes to
+     * the host we connected to, so we don't need to explicitly
+     * give the host. */
+    return channel.writeGathering(srcs, offset, length);
   }
 
   public int read (ByteBuffer dst)
@@ -167,9 +183,7 @@
     if (!isConnected ())
       throw new NotYetConnectedException ();
     
-    int remaining = dst.remaining();
-    receive (dst);
-    return remaining - dst.remaining();
+    return channel.read(dst);
   }
     
   public long read (ByteBuffer[] dsts, int offset, int length)
@@ -184,12 +198,8 @@
         || (length > (dsts.length - offset)))
       throw new IndexOutOfBoundsException();
       
-    long result = 0;
-
-    for (int index = offset; index < offset + length; index++)
-      result += read (dsts [index]);
-
-    return result;
+    /* Likewise, see the comment int write above. */
+    return channel.readScattering(dsts, offset, length);
   }
     
   public SocketAddress receive (ByteBuffer dst)
@@ -200,51 +210,14 @@
     
     try
       {
-        DatagramPacket packet;
-        int len = dst.remaining();
-        
-        if (dst.hasArray())
-          {
-            packet = new DatagramPacket (dst.array(),
-                                         dst.arrayOffset() + dst.position(),
-                                         len);
-          }
-        else
-          {
-            packet = new DatagramPacket (new byte [len], len);
-  }
-    
-        boolean completed = false;
-
-        try
-          {
-            begin();
-            setInChannelOperation(true);
-            socket.receive (packet);
-            completed = true;
-          }
-        finally
-  {
-            end (completed);
-            setInChannelOperation(false);
-  }
-    
-        if (!dst.hasArray())
-          {
-            dst.put (packet.getData(), packet.getOffset(), packet.getLength());
-          }
-        else
-  {
-            dst.position (dst.position() + packet.getLength());
-  }
-    
-        return packet.getSocketAddress();
+        begin();
+        return channel.receive(dst);
       }
-    catch (SocketTimeoutException e)
-  {
-    return null;
+    finally
+      {
+        end(true);
+      }
   }
-  }
     
   public int send (ByteBuffer src, SocketAddress target)
     throws IOException
@@ -252,46 +225,18 @@
     if (!isOpen())
       throw new ClosedChannelException();
     
-    if (target instanceof InetSocketAddress
-	&& ((InetSocketAddress) target).isUnresolved())
+    if (!(target instanceof InetSocketAddress))
+      throw new IOException("can only send to inet socket addresses");
+    
+    InetSocketAddress dst = (InetSocketAddress) target;
+    if (dst.isUnresolved())
       throw new IOException("Target address not resolved");
 
-    byte[] buffer;
-    int offset = 0;
-    int len = src.remaining();
-    
-    if (src.hasArray())
-      {
-        buffer = src.array();
-        offset = src.arrayOffset() + src.position();
-      }
-    else
-      {
-        buffer = new byte [len];
-        src.get (buffer);
+    return channel.send(src, dst);
   }
-    
-    DatagramPacket packet = new DatagramPacket (buffer, offset, len, target);
-
-    boolean completed = false;
-    try
+  
+  public VMChannel getVMChannel()
   {
-        begin();
-        setInChannelOperation(true);
-        socket.send(packet);
-        completed = true;
-      }
-    finally
-      {
-        end (completed);
-        setInChannelOperation(false);
-      }
-      
-    if (src.hasArray())
-      {
-	src.position (src.position() + len);
-      }
-
-    return len;
+    return channel;
   }
 }

Modified: trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelSelectionKey.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelSelectionKey.java	2006-12-13 19:25:39 UTC (rev 2906)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/DatagramChannelSelectionKey.java	2006-12-14 09:24:37 UTC (rev 2907)
@@ -38,6 +38,7 @@
 
 package gnu.java.nio;
 
+import java.io.IOException;
 import java.nio.channels.spi.AbstractSelectableChannel;
 
 /**
@@ -52,10 +53,16 @@
     super (channel, selector);
   }
 
+  // FIXME don't use file descriptor integers
   public int getNativeFD()
   {
-    NIODatagramSocket socket =
-      (NIODatagramSocket) ((DatagramChannelImpl) ch).socket();
-    return socket.getPlainDatagramSocketImpl().getNativeFD();
+    try
+      {
+        return ((DatagramChannelImpl) ch).getVMChannel().getState().getNativeFD();
+      }
+    catch (IOException ioe)
+      {
+        throw new IllegalStateException(ioe);
+      }
   }
 }

Added: trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectionKeyImpl.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectionKeyImpl.java	                        (rev 0)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectionKeyImpl.java	2006-12-14 09:24:37 UTC (rev 2907)
@@ -0,0 +1,122 @@
+/* EpollSelectionKeyImpl.java -- selection key for the epoll selector.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.nio;
+
+import java.io.IOException;
+import java.nio.channels.CancelledKeyException;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.spi.AbstractSelectionKey;
+
+/**
+ * @author Casey Marshall (cs...@gn...)
+ */
+public class EpollSelectionKeyImpl extends AbstractSelectionKey
+{
+  final int fd;
+  private final EpollSelectorImpl selector;
+  private final SelectableChannel channel;
+  int interestOps;
+  int selectedOps;
+  int key;
+  boolean valid;
+  boolean cancelled;
+  
+  EpollSelectionKeyImpl(EpollSelectorImpl selector,
+                        SelectableChannel channel, int fd)
+  {
+    this.selector = selector;
+    this.channel = channel;
+    this.fd = fd;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#channel()
+   */
+  public SelectableChannel channel()
+  {
+    return channel;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#interestOps()
+   */
+  public int interestOps()
+  {
+    return interestOps;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#interestOps(int)
+   */
+  public SelectionKey interestOps(int ops)
+  {
+    if (cancelled)
+      throw new CancelledKeyException();
+    if ((ops & ~(channel.validOps())) != 0)
+      throw new IllegalArgumentException("unsupported channel ops");
+    try
+      {
+        selector.epoll_modify(this, ops);
+        interestOps = ops;
+      }
+    catch (IOException ioe)
+      {
+        throw new IllegalArgumentException(ioe);
+      }
+    return this;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#readyOps()
+   */
+  public int readyOps()
+  {
+    return selectedOps;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#selector()
+   */
+  public Selector selector()
+  {
+    return selector;
+  }
+}

Added: trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectorImpl.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectorImpl.java	                        (rev 0)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/EpollSelectorImpl.java	2006-12-14 09:24:37 UTC (rev 2907)
@@ -0,0 +1,399 @@
+/* EpollSelectorImpl.java -- selector implementation using epoll
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.nio;
+
+import gnu.classpath.Configuration;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.spi.AbstractSelectableChannel;
+import java.nio.channels.spi.AbstractSelector;
+import java.nio.channels.spi.SelectorProvider;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * An implementation of {@link Selector} that uses the epoll event
+ * notification mechanism on GNU/Linux.
+ *
+ * @author Casey Marshall (cs...@gn...)
+ */
+public class EpollSelectorImpl extends AbstractSelector
+{
+  // XXX is this reasonable? Does it matter?
+  private static final int DEFAULT_EPOLL_SIZE = 128;
+  private static final int sizeof_struct_epoll_event;
+  
+  private static final int OP_ACCEPT  = SelectionKey.OP_ACCEPT;
+  private static final int OP_CONNECT = SelectionKey.OP_CONNECT;
+  private static final int OP_READ    = SelectionKey.OP_READ;
+  private static final int OP_WRITE   = SelectionKey.OP_WRITE;
+  
+  /** our epoll file descriptor. */
+  private int epoll_fd;
+  
+  private final HashMap keys;
+  private Set selectedKeys;
+  private Thread waitingThread;
+  private ByteBuffer events;
+  
+  private static final int INITIAL_CAPACITY;
+  private static final int MAX_DOUBLING_CAPACITY;
+  private static final int CAPACITY_INCREMENT;
+
+  static
+  {
+    if (Configuration.INIT_LOAD_LIBRARY)
+      System.loadLibrary("javanio");
+    
+    if (epoll_supported())
+      sizeof_struct_epoll_event = sizeof_struct();
+    else
+      sizeof_struct_epoll_event = -1;
+    
+    INITIAL_CAPACITY = 64 * sizeof_struct_epoll_event;
+    MAX_DOUBLING_CAPACITY = 1024 * sizeof_struct_epoll_event;
+    CAPACITY_INCREMENT = 128 * sizeof_struct_epoll_event;
+  }
+  
+  public EpollSelectorImpl(SelectorProvider provider)
+    throws IOException
+  {
+    super(provider);
+    epoll_fd = epoll_create(DEFAULT_EPOLL_SIZE);
+    keys = new HashMap();
+    selectedKeys = null;
+    events = ByteBuffer.allocateDirect(INITIAL_CAPACITY);
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.Selector#keys()
+   */
+  public Set keys()
+  {
+    return new HashSet(keys.values());
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.Selector#select()
+   */
+  public int select() throws IOException
+  {
+    return doSelect(-1);
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.Selector#select(long)
+   */
+  public int select(long timeout) throws IOException
+  {
+    if (timeout > Integer.MAX_VALUE)
+      throw new IllegalArgumentException("timeout is too large");
+    if (timeout < 0)
+      throw new IllegalArgumentException("invalid timeout");
+    return doSelect((int) timeout);
+  }
+    
+  private int doSelect(int timeout) throws IOException
+  {
+    synchronized (keys)
+    {
+      Set cancelledKeys = cancelledKeys();
+      synchronized (cancelledKeys)
+      {
+        for (Iterator it = cancelledKeys.iterator(); it.hasNext(); )
+          {
+            EpollSelectionKeyImpl key = (EpollSelectionKeyImpl) it.next();
+            epoll_delete(epoll_fd, key.fd);
+            key.valid = false;
+            keys.remove(Integer.valueOf(key.fd));
+            it.remove();
+            deregister(key);
+          }
+        
+        // Clear out closed channels. The fds are removed from the epoll
+        // fd when closed, so there is no need to remove them manually.
+        for (Iterator it = keys.values().iterator(); it.hasNext(); )
+          {
+            EpollSelectionKeyImpl key = (EpollSelectionKeyImpl) it.next();
+            SelectableChannel ch = key.channel();
+            if (ch instanceof VMChannelOwner)
+              {
+                if (!((VMChannelOwner) ch).getVMChannel().getState().isValid())
+                  it.remove();
+              }
+          }
+        
+        // Don't bother if we have nothing to select.
+        if (keys.isEmpty())
+          return 0;
+
+        int ret;
+        try
+          {
+            begin();
+            waitingThread = Thread.currentThread();
+            ret = epoll_wait(epoll_fd, events, keys.size(), timeout);
+          }
+        finally
+          {
+            Thread.interrupted();
+            waitingThread = null;
+            end();
+          }
+      
+        HashSet s = new HashSet(ret);
+        for (int i = 0; i < ret; i++)
+          {
+            events.position(i * sizeof_struct_epoll_event);
+            ByteBuffer b = events.slice();
+            int fd = selected_fd(b);
+            EpollSelectionKeyImpl key
+              = (EpollSelectionKeyImpl) keys.get(Integer.valueOf(fd));
+            if (key == null)
+              throw new IOException("fd was selected, but no key found");
+            key.selectedOps = selected_ops(b) & key.interestOps;
+            s.add(key);
+          }
+        
+        reallocateBuffer();
+        
+        selectedKeys = s;
+        return ret;
+      }
+    }
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.Selector#selectedKeys()
+   */
+  public Set selectedKeys()
+  {
+    if (selectedKeys == null)
+      return Collections.EMPTY_SET;
+    return selectedKeys;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.Selector#selectNow()
+   */
+  public int selectNow() throws IOException
+  {
+    return doSelect(0);
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.Selector#wakeup()
+   */
+  public Selector wakeup()
+  {
+    try
+      {
+        waitingThread.interrupt();
+      }
+    catch (NullPointerException npe)
+      {
+        // Ignored, thrown if we are not in a blocking op.
+      }
+    return this;
+  }
+  
+  /* (non-Javadoc)
+   * @see java.nio.channels.spi.AbstractSelector#implCloseSelector()
+   */
+  protected void implCloseSelector() throws IOException
+  {
+    VMChannel.close(epoll_fd);
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.spi.AbstractSelector#register(java.nio.channels.spi.AbstractSelectableChannel, int, java.lang.Object)
+   */
+  protected SelectionKey register(AbstractSelectableChannel ch, int ops, Object att)
+  {
+    if (!(ch instanceof VMChannelOwner))
+      throw new IllegalArgumentException("unsupported channel type");
+
+    VMChannel channel = ((VMChannelOwner) ch).getVMChannel();
+    try
+      {
+        int native_fd = channel.getState().getNativeFD();
+        synchronized (keys)
+        {
+          if (keys.containsKey(Integer.valueOf(native_fd)))
+            throw new IllegalArgumentException("channel already registered");
+          EpollSelectionKeyImpl result =
+            new EpollSelectionKeyImpl(this, ch, native_fd);
+          if ((ops & ~(ch.validOps())) != 0)
+            throw new IllegalArgumentException("invalid ops for channel");
+          result.interestOps = ops;
+          result.selectedOps = 0;
+          result.valid = true;
+          result.attach(att);
+          result.key = System.identityHashCode(result);
+          epoll_add(epoll_fd, result.fd, ops);
+          keys.put(Integer.valueOf(native_fd), result);
+	  reallocateBuffer();
+          return result;
+        }
+      }
+    catch (IOException ioe)
+      {
+        throw new IllegalArgumentException(ioe);
+      }
+  }
+  
+  private void reallocateBuffer()
+  {
+    // Ensure we have enough space for all potential events that may be
+    // returned.
+    if (events.capacity() < keys.size() * sizeof_struct_epoll_event)
+      {
+        int cap = events.capacity();
+        if (cap < MAX_DOUBLING_CAPACITY)
+          cap <<= 1;
+        else
+          cap += CAPACITY_INCREMENT;
+        events = ByteBuffer.allocateDirect(cap);
+      }
+    // Ensure that the events buffer is not too large, given the number of
+    // events registered.
+    else if (events.capacity() > keys.size() * sizeof_struct_epoll_event * 2 + 1
+	     && events.capacity() > INITIAL_CAPACITY)
+      {
+        int cap = events.capacity() >>> 1;
+        events = ByteBuffer.allocateDirect(cap);
+      }
+  }
+  
+  void epoll_modify(EpollSelectionKeyImpl key, int ops) throws IOException
+  {
+    epoll_modify(epoll_fd, key.fd, ops);
+  }
+  
+  /**
+   * Tell if epoll is supported by this system, and support was compiled in.
+   *
+   * @return True if this system supports event notification with epoll.
+   */
+  public static native boolean epoll_supported();
+
+
+  /**
+   * Returns the size of `struct epoll_event'.
+   *
+   * @return The size of `struct epoll_event'.
+   */
+  private static native int sizeof_struct();
+  
+ 
+  /**
+   * Open a new epoll file descriptor.
+   *
+   * @param size The size hint for the new epoll descriptor.
+   * @return The new file descriptor integer.
+   * @throws IOException If allocating a new epoll descriptor fails.
+   */
+  private static native int epoll_create(int size) throws IOException;
+  
+  /**
+   * Add a file descriptor to this selector.
+   *
+   * @param efd The epoll file descriptor.
+   * @param fd  The file descriptor to add (or modify).
+   * @param ops The interest opts.
+   */
+  private static native void epoll_add(int efd, int fd, int ops)
+    throws IOException;
+  
+  /**
+   * Modify the interest ops of the key selecting for the given FD.
+   *
+   * @param efd The epoll file descriptor.
+   * @param fd  The file descriptor to modify.
+   * @param ops The ops.
+   * @throws IOException
+   */
+  private static native void epoll_modify(int efd, int fd, int ops)
+    throws IOException;
+  
+  /**
+   * Remove a file descriptor from this selector.
+   *
+   * @param efd The epoll file descriptor.
+   * @param fd  The file descriptor.
+   * @throws IOException
+   */
+  private static native void epoll_delete(int efd, int fd) throws IOException;
+  
+  /**
+   * Select events.
+   *
+   * @param efd     The epoll file descriptor.
+   * @param state   The buffer to hold selected events.
+   * @param n       The number of events that may be put in `state'.
+   * @param timeout The timeout.
+   * @return The number of events selected.
+   * @throws IOException
+   */
+  private static native int epoll_wait(int efd, ByteBuffer state, int n, int timeout)
+    throws IOException;
+  
+  /**
+   * Fetch the fd value from a selected struct epoll_event.
+   *
+   * @param struct The direct buffer holding the struct.
+   * @return The fd value.
+   */
+  private static native int selected_fd(ByteBuffer struct);
+  
+  /**
+   * Fetch the enabled operations from a selected struct epoll_event.
+   *
+   * @param struct The direct buffer holding the struct.
+   * @return The selected operations.
+   */
+  private static native int selected_ops(ByteBuffer struct);
+}

Modified: trunk/core/src/classpath/gnu/gnu/java/nio/FileLockImpl.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/FileLockImpl.java	2006-12-13 19:25:39 UTC (rev 2906)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/FileLockImpl.java	2006-12-14 09:24:37 UTC (rev 2907)
@@ -38,8 +38,6 @@
 
 package gnu.java.nio;
 
-import gnu.java.nio.channels.FileChannelImpl;
-
 import java.io.IOException;
 import java.nio.channels.FileLock;
 

Added: trunk/core/src/classpath/gnu/gnu/java/nio/KqueueSelectionKeyImpl.java
===================================================================
--- trunk/core/src/classpath/gnu/gnu/java/nio/KqueueSelectionKeyImpl.java	                        (rev 0)
+++ trunk/core/src/classpath/gnu/gnu/java/nio/KqueueSelectionKeyImpl.java	2006-12-14 09:24:37 UTC (rev 2907)
@@ -0,0 +1,189 @@
+/* KqueueSelectionKeyImpl.java -- selection key for kqueue/kevent.
+   Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.nio;
+
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.spi.AbstractSelectionKey;
+
+/**
+ * @author Casey Marshall (cs...@gn...)
+ */
+public class KqueueSelectionKeyImpl extends AbstractSelectionKey
+{
+  int interestOps;
+  int readyOps;
+  int activeOps = 0;
+  int key;
+  int fd;
+
+  /** The selector we were created for. */
+  private final KqueueSelectorImpl selector;
+  
+  /** The channel we are attached to. */
+  private final SelectableChannel channel;
+  
+  private final VMChannelOwner natChannel;
+  
+  public KqueueSelectionKeyImpl(KqueueSelectorImpl selector,
+                                SelectableChannel channel)
+  {
+    this.selector = selector;
+    this.channel = channel;
+    natChannel = (VMChannelOwner) channel;
+    interestOps = 0;
+    readyOps = 0;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#channel()
+   */
+  //@Override
+  public SelectableChannel channel()
+  {
+    return channel;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#interestOps()
+   */
+  //@Override
+  public int interestOps()
+  {
+    return interestOps;
+  }
+
+  /* (non-Javadoc)
+   * @see java.nio.channels.SelectionKey#interestOps(int)
+   */
+  //@Override
+  public SelectionKey interestOps(int ops)
+  {
+    if (!isValid())
+      throw new IllegalStateException("key is invalid");
+    if ((ops & ~channel.validOps()) != 0)
+      throw new IllegalArgumentException("channel does not support all operations");
+    
+    selector.setInterestOps(this,...
 
[truncated message content]

Thread: [Jnode-svn-commits] SF.net SVN: jnode: [2907] trunk/core/src/classpath/gnu/gnu/java/nio

jnode-svn-commits