changeset 7045:a7f1881673cd

8034181: SIGBUS in SctpChannelImpl receive Reviewed-by: alanb, dsamersoff
author chegar
date Wed, 26 Mar 2014 20:35:47 +0000
parents 6bac2d7b0d04
children b7fbd9b4febf 0b2b0051e7a1
files src/solaris/native/sun/nio/ch/SctpChannelImpl.c test/com/sun/nio/sctp/SctpChannel/ReceiveIntoDirect.java
diffstat 2 files changed, 317 insertions(+), 8 deletions(-) [+]
line wrap: on
line diff
--- a/src/solaris/native/sun/nio/ch/SctpChannelImpl.c	Tue Apr 01 21:24:31 2014 -0700
+++ b/src/solaris/native/sun/nio/ch/SctpChannelImpl.c	Wed Mar 26 20:35:47 2014 +0000
@@ -38,8 +38,7 @@
 #include "sun_nio_ch_SctpResultContainer.h"
 #include "sun_nio_ch_SctpPeerAddrChange.h"
 
-/* sizeof(union sctp_notification */
-#define NOTIFICATION_BUFFER_SIZE 280
+static int SCTP_NOTIFICATION_SIZE = sizeof(union sctp_notification);
 
 #define MESSAGE_IMPL_CLASS              "sun/nio/ch/SctpMessageInfoImpl"
 #define RESULT_CONTAINER_CLASS          "sun/nio/ch/SctpResultContainer"
@@ -458,20 +457,47 @@
         if (msg->msg_flags & MSG_NOTIFICATION) {
             char *bufp = (char*)addr;
             union sctp_notification *snp;
+            jboolean allocated = JNI_FALSE;
 
-            if (!(msg->msg_flags & MSG_EOR) && length < NOTIFICATION_BUFFER_SIZE) {
-                char buf[NOTIFICATION_BUFFER_SIZE];
+            if (rv > SCTP_NOTIFICATION_SIZE) {
+                JNU_ThrowInternalError(env, "should not reach here");
+                return -1;
+            }
+
+            if (!(msg->msg_flags & MSG_EOR) && length < SCTP_NOTIFICATION_SIZE) {
+                char* newBuf;
                 int rvSAVE = rv;
-                memcpy(buf, addr, rv);
-                iov->iov_base = buf + rv;
-                iov->iov_len = NOTIFICATION_BUFFER_SIZE - rv;
+
+                if ((newBuf = malloc(SCTP_NOTIFICATION_SIZE)) == NULL) {
+                    JNU_ThrowOutOfMemoryError(env, "Out of native heap space.");
+                    return -1;
+                }
+                allocated = JNI_TRUE;
+
+                memcpy(newBuf, addr, rv);
+                iov->iov_base = newBuf + rv;
+                iov->iov_len = SCTP_NOTIFICATION_SIZE - rv;
                 if ((rv = recvmsg(fd, msg, flags)) < 0) {
                     handleSocketError(env, errno);
                     return 0;
                 }
-                bufp = buf;
+                bufp = newBuf;
                 rv += rvSAVE;
             }
+#ifdef __sparc
+              else if ((intptr_t)addr & 0x3) {
+                /* the given buffer is not 4 byte aligned */
+                char* newBuf;
+                if ((newBuf = malloc(SCTP_NOTIFICATION_SIZE)) == NULL) {
+                    JNU_ThrowOutOfMemoryError(env, "Out of native heap space.");
+                    return -1;
+                }
+                allocated = JNI_TRUE;
+
+                memcpy(newBuf, addr, rv);
+                bufp = newBuf;
+            }
+#endif
             snp = (union sctp_notification *) bufp;
             if (handleNotification(env, fd, resultContainerObj, snp, rv,
                                    (msg->msg_flags & MSG_EOR),
@@ -479,9 +505,16 @@
                 /* We have received a notification that is of interest to
                    to the Java API. The appropriate notification will be
                    set in the result container. */
+                if (allocated == JNI_TRUE) {
+                    free(bufp);
+                }
                 return 0;
             }
 
+            if (allocated == JNI_TRUE) {
+                free(bufp);
+            }
+
             // set iov back to addr, and reset msg_controllen
             iov->iov_base = addr;
             iov->iov_len = length;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/com/sun/nio/sctp/SctpChannel/ReceiveIntoDirect.java	Wed Mar 26 20:35:47 2014 +0000
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2014, 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 8034181
+ * @summary SIGBUS in SctpChannelImpl receive
+ * @author chegar
+ */
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import com.sun.nio.sctp.AbstractNotificationHandler;
+import com.sun.nio.sctp.AssociationChangeNotification;
+import com.sun.nio.sctp.AssociationChangeNotification.AssocChangeEvent;
+import com.sun.nio.sctp.HandlerResult;
+import com.sun.nio.sctp.MessageInfo;
+import com.sun.nio.sctp.Notification;
+import com.sun.nio.sctp.PeerAddressChangeNotification;
+import com.sun.nio.sctp.SctpChannel;
+import com.sun.nio.sctp.SctpServerChannel;
+import com.sun.nio.sctp.ShutdownNotification;
+import static java.lang.System.out;
+import static java.lang.System.err;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+
+public class ReceiveIntoDirect {
+    /* suitably small message to NOT overrun small buffers */
+    final byte[] msgBytes =  "Hello".getBytes(US_ASCII);
+
+    /* number of client connections/combinations (accepted by the server) */
+    final int NUM_CONNECTIONS = 75;
+
+    void test(String[] args) throws IOException {
+        SocketAddress address = null;
+        Server server;
+
+        if (!Util.isSCTPSupported()) {
+            out.println("SCTP protocol is not supported");
+            out.println("Test cannot be run");
+            return;
+        }
+
+        if (args.length == 2) {
+            /* requested to connecct to a specific address */
+            try {
+                int port = Integer.valueOf(args[1]);
+                address = new InetSocketAddress(args[0], port);
+            } catch (NumberFormatException nfe) {
+                err.println(nfe);
+            }
+        } else {
+            /* start server on local machine, default */
+            server = new Server();
+            server.start();
+            address = server.address();
+            debug("Server started and listening on " + address);
+        }
+
+        /* many combinations with varing buffer sizes, and offsets */
+        runWithManyOffsets(address, 20);
+        runWithManyOffsets(address, 49);
+        runWithManyOffsets(address, 50);
+        runWithManyOffsets(address, 51);
+        runWithManyOffsets(address, 1024);
+    }
+
+    void runWithManyOffsets(SocketAddress addr, int bufferSize)
+        throws IOException
+    {
+        doTest(addr, bufferSize, 1);
+        doTest(addr, bufferSize, 2);
+        doTest(addr, bufferSize, 3);
+        doTest(addr, bufferSize, 4);
+        doTest(addr, bufferSize, 5);
+        doTest(addr, bufferSize, 6);
+        doTest(addr, bufferSize, 7);
+        doTest(addr, bufferSize, 8);
+        doTest(addr, bufferSize, 9);
+        doTest(addr, bufferSize, 10);
+        doTest(addr, bufferSize, 11);
+        doTest(addr, bufferSize, 12);
+        doTest(addr, bufferSize, 13);
+        doTest(addr, bufferSize, 14);
+        doTest(addr, bufferSize, 15);
+    }
+
+    void doTest(SocketAddress peerAddress, int bufferSize, int bufferOffset)
+        throws IOException
+    {
+        debug("\n\nTesting with bufferSize " + bufferSize + " and offset " + bufferOffset);
+        assert bufferOffset + msgBytes.length <= bufferSize :
+               "buffer offset + message length greater than buffer size ";
+
+        ByteBuffer buffer = ByteBuffer.allocateDirect(bufferSize);
+        MessageInfo info;
+
+        try (SctpChannel channel = SctpChannel.open()) {
+            channel.connect(peerAddress);
+
+            ReceiveNotificationHandler handler =
+                new ReceiveNotificationHandler();
+
+            /* TEST 1: Assoc/peer change notif into direct buffer with offest */
+            do {
+                debug("Test 1: Assoc/peer change with offset " + bufferOffset);
+                buffer.position(bufferOffset);
+                info = channel.receive(buffer, null, handler);
+                if (info == null) {
+                    fail("unexpected null from receive");
+                    return;
+                }
+            } while (!info.isComplete());
+
+            buffer.flip().position(bufferOffset);
+            check(handler.receivedCommUp(), "SCTP_COMM_UP not received");
+            check(info != null, "info is null");
+            check(info.address() != null, "address is null");
+            check(info.association() != null, "association is null");
+            check(info.isComplete(), "message is not complete");
+            check(info.isUnordered() != true,
+                  "message should not be unordered");
+            check(info.streamNumber() >= 0, "invalid stream number");
+            check(info.bytes() == msgBytes.length,
+                  "bytes received not equal to message length");
+            check(info.bytes() == buffer.remaining(), "bytes != remaining");
+            check(Util.compare(buffer, msgBytes),
+                  "received message not the same as sent message");
+
+            /* TEST 2: shutdown notification with offset */
+            debug("Test 2: shutdown notif with offset " + bufferOffset);
+            buffer.clear().position(bufferOffset);
+            while ((info = channel.receive(buffer, null, handler )) != null &&
+                    info.bytes() != -1 );
+        }
+    }
+
+    class Server implements Runnable
+    {
+        private final InetSocketAddress serverAddr;
+        private final SctpServerChannel ssc;
+
+        public Server() throws IOException {
+            ssc = SctpServerChannel.open().bind(null);
+            java.util.Set<SocketAddress> addrs = ssc.getAllLocalAddresses();
+            if (addrs.isEmpty())
+                debug("addrs should not be empty");
+
+            serverAddr = (InetSocketAddress) addrs.iterator().next();
+        }
+
+        public void start() {
+            (new Thread(this, "Server-"  + serverAddr.getPort())).start();
+        }
+
+        public InetSocketAddress address() {
+            return serverAddr;
+        }
+
+        @Override
+        public void run() {
+            try {
+                for (int i=0; i<NUM_CONNECTIONS; i++) {
+                    SctpChannel sc = ssc.accept();
+
+                    /* send a small message */
+                    MessageInfo info = MessageInfo.createOutgoing(null, 0);
+                    ByteBuffer buf = ByteBuffer.allocateDirect(Util.SMALL_BUFFER);
+                    buf.put(msgBytes);
+                    buf.flip();
+
+                    debug("sending small message: " + buf);
+                    sc.send(buf, info);
+
+                    sc.shutdown();
+                    sc.close();
+                }
+            } catch (IOException x) {
+                unexpected(x);
+            } finally {
+                try { ssc.close(); }
+                catch (IOException x) { unexpected(x); }
+            }
+        }
+    }
+
+    class ReceiveNotificationHandler extends AbstractNotificationHandler<Object>
+    {
+        boolean receivedCommUp;  // false
+
+        public ReceiveNotificationHandler() { }
+
+        public boolean receivedCommUp() {
+            return receivedCommUp;
+        }
+
+        @Override
+        public HandlerResult handleNotification(
+                Notification notification, Object attachment) {
+            fail("Unknown notification type");
+            return HandlerResult.CONTINUE;
+        }
+
+        @Override
+        public HandlerResult handleNotification(
+                AssociationChangeNotification notification, Object attachment) {
+            AssocChangeEvent event = notification.event();
+            debug("AssociationChangeNotification");
+            debug("  Association: " + notification.association());
+            debug("  Event: " + event);
+
+            if (event.equals(AssocChangeEvent.COMM_UP))
+                receivedCommUp = true;
+
+            return HandlerResult.CONTINUE;
+        }
+
+        @Override
+        public HandlerResult handleNotification(
+                PeerAddressChangeNotification pacn, Object unused)
+        {
+            debug("PeerAddressChangeNotification: " +  pacn);
+            return HandlerResult.CONTINUE;
+        }
+
+        @Override
+        public HandlerResult handleNotification(
+                ShutdownNotification notification, Object attachment) {
+            debug("ShutdownNotification");
+            debug("  Association: " + notification.association());
+            return HandlerResult.CONTINUE;
+        }
+    }
+        //--------------------- Infrastructure ---------------------------
+    boolean debug = true;
+    volatile int passed = 0, failed = 0;
+    void pass() {passed++;}
+    void fail() {failed++; Thread.dumpStack();}
+    void fail(String msg) {System.err.println(msg); fail();}
+    void unexpected(Throwable t) {failed++; t.printStackTrace();}
+    void check(boolean cond) {if (cond) pass(); else fail();}
+    void check(boolean cond, String failMessage) {if (cond) pass(); else fail(failMessage);}
+    void debug(String message) {if(debug) {
+          System.out.println(Thread.currentThread() + " " + message); } }
+    public static void main(String[] args) throws Throwable {
+        Class<?> k = new Object(){}.getClass().getEnclosingClass();
+        try {k.getMethod("instanceMain",String[].class)
+                .invoke( k.newInstance(), (Object) args);}
+        catch (Throwable e) {throw e.getCause();}}
+    public void instanceMain(String[] args) throws Throwable {
+        try {test(args);} catch (Throwable t) {unexpected(t);}
+        System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
+        if (failed > 0) throw new AssertionError("Some tests failed");}
+
+}