--- /dev/null	2018-06-20 11:01:03.657616567 -0700
+++ new/test/jdk/jdk/net/Sockets/rsocket/Selector/RegisterDuringSelect.java	2018-06-22 12:24:07.647671638 -0700
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2018, 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.
+ *
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8195160
+ * @summary Test that RDMA channels can be registered, interest ops can changed,
+ *          and keys cancelled while a selection operation is in progress.
+ * @requires (os.family == "linux")
+ * @library .. /test/lib
+ * @build RsocketTest
+ * @run main/othervm -Djava.net.preferIPv4Stack=true BasicAccept
+ */
+import java.io.IOException;
+import java.nio.channels.Pipe;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.Phaser;
+import jdk.net.Sockets;
+
+public class RegisterDuringSelect {
+
+    static Callable<Void> selectLoop(Selector sel, Phaser barrier) {
+        return new Callable<Void>() {
+            @Override
+            public Void call() throws IOException {
+                for (;;) {
+                    sel.select();
+                    if (sel.isOpen()) {
+                        barrier.arriveAndAwaitAdvance();
+                    } else {
+                        // closed
+                        return null;
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Invoke register, interestOps, and cancel concurrently with a thread
+     * doing a selection operation
+     */
+    public static void main(String args[]) throws Exception {
+        if (!RsocketTest.isRsocketAvailable())
+            return;
+
+        Future<Void> result;
+
+        ExecutorService pool = Executors.newFixedThreadPool(1);
+        try (Selector sel = Sockets.openRdmaSelector()) {
+            Phaser barrier = new Phaser(2);
+
+            // submit task to do the select loop
+            result = pool.submit(selectLoop(sel, barrier));
+
+            Pipe p = Pipe.open();
+            try {
+                Pipe.SourceChannel sc = p.source();
+                sc.configureBlocking(false);
+
+                System.out.println("register ...");
+                SelectionKey key = sc.register(sel, SelectionKey.OP_READ);
+                if (!sel.keys().contains(key))
+                    throw new RuntimeException("key not in key set");
+                sel.wakeup();
+                barrier.arriveAndAwaitAdvance();
+
+                System.out.println("interestOps ...");
+                key.interestOps(0);
+                sel.wakeup();
+                barrier.arriveAndAwaitAdvance();
+
+                System.out.println("cancel ...");
+                key.cancel();
+                sel.wakeup();
+                barrier.arriveAndAwaitAdvance();
+                if (sel.keys().contains(key))
+                    throw new RuntimeException("key not removed from key set");
+
+            } finally {
+                p.source().close();
+                p.sink().close();
+            }
+
+        } finally {
+            pool.shutdown();
+        }
+
+        // ensure selectLoop completes without exception
+        result.get();
+
+    }
+}