FULL PRODUCT VERSION :


A DESCRIPTION OF THE PROBLEM :
As noted at JDK-8049846, the implementation of Java_java_net_SocketInputStream_socketRead0 assumes that read() won't block after poll() reports that a read is possible. This assumption does not hold, as noted on the man page for select (referenced by the man page for poll): Under Linux, select() may report a socket file descriptor as "ready for reading", while nevertheless a subsequent read blocks. This could for example happen when data has arrived but upon examination has wrong checksum and is discarded. There may be other circumstances in which a file descriptor is spuriously reported as ready. Thus it may be safer to use O_NONBLOCK on sockets that should not block.

In production, we hit this about once a day. For testing and reproduction purposes, we can use fault injection to get spurious poll() results on demand.

[This report is probably more appropriate as a comment on JDK-8049846, but commenting requires an account, and obtaining an account does not appear to be an easy task]

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
1. Create file called poll.c with contents:
-----
#define _GNU_SOURCE
#include <poll.h>
#include <dlfcn.h>
#include <stdio.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout) {
  static int n;
  if ((++n & 0x3) == 0) {
    // Fault injection: perhaps we should report a spurious readiness notification
    int i;
    for (i = 0; i < nfds; ++i) {
      if (fds[i].events & POLLIN) {
        fds[i].revents |= POLLIN;
return 1;
      }
    }
  }
  return ((int(*)(struct pollfd*,nfds_t,int))dlsym(RTLD_NEXT, "poll"))(fds, nfds, timeout);
}
-----

2. Create file called OneReaderThread.java with contents:
-----
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class OneReaderThread {
public static void main(String[] args) throws IOException {
@SuppressWarnings("resource")
ServerSocket serverSocket = new ServerSocket(17291);
new ReadingThreadA().start();
Socket client = serverSocket.accept();
OutputStream os = client.getOutputStream();
byte[] writeData = new byte[2];
for (;;) {
waitingForA = true;
long start = System.currentTimeMillis();
while (waitingForA) {
long now = System.currentTimeMillis();
if (now > start + 500) {
// 500ms have passed, which is 10x the read timeout
System.out.println("Should never happen: A is unresponsive");
os.write(writeData);
break;
}
}
}
}

private static volatile boolean waitingForA;

private static final class ReadingThreadA extends Thread {
@Override
public void run() {
try {
@SuppressWarnings("resource")
Socket s = new Socket("localhost", 17291);
s.setSoTimeout(50); // SO_TIMEOUT is set, meaning that reads should not block for more than 50ms
final InputStream is = s.getInputStream();
byte[] readDataA = new byte[2];
for (;;) {
int n = 0;
try {
n = is.read(readDataA);
} catch (IOException e) {
// Ignore
}
System.out.println("A tick (" + n + ")");
waitingForA = false; // This assignment should happen at least once every 50ms
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
-----

3. Compile the C code: gcc -o poll.so -shared poll.c -ldl -fPIC
4. Compile the Java code: javac OneReaderThread.java
5. Run the Java code with the C library preloaded: LD_PRELOAD=./poll.so java -cp . OneReaderThread

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Expect an output stream consisting solely of:
A tick (0)
A tick (0)
A tick (0)
A tick (0)
A tick (0)
A tick (0)
A tick (0)
A tick (0)
ACTUAL -
Actual output stream is repetitions of:
Should never happen: A is unresponsive
A tick (2)
A tick (0)
A tick (0)
A tick (0)
Should never happen: A is unresponsive
A tick (2)
A tick (0)
A tick (0)
A tick (0)

REPRODUCIBILITY :
This bug can be reproduced occasionally.