stop_reading causes a seg fault under certain conditions

[amitmurthy]

The code below simulates the seg fault mentioned in #3437 . It models the typical flow in multi.jl.

To simulate :

1. Copy and execute the below code in a Julia session

function accept_sock(server::Base.TcpServer, status::Int32)
    if(status == -1)
        error("An error occured during the creation of the server")
    end
    sock = Base.accept_nonblock(server)
    process_sock(sock)
end

function add_to_workq(t::Task)
    ccall(:uv_stop,Void,(Ptr{Void},),Base.eventloop())
    unshift!(Base.Workqueue, t)
end


function process_sock(sock::AsyncStream) 
    add_to_workq(@task begin
        start_reading(sock)
        Base.wait_connected(sock)
        println("After wait_connected")
        try
            while true
                c=read(sock, Uint8)
                print(c)
            end
        catch e
            println("Caught exception $e")
            stop_reading(sock)
            return nothing
        end
    end)
end


(actual_port,sock) = open_any_tcp_port(accept_sock,8000) 
println(dec(actual_port))

1. Open at least 3 telnet connections to the port printed above using telnet localhost 8000
2. tickle all the connections by typing any keys in the telnet sessions
3. execute killall telnet
4. On the Julia session you should see :

julia> (actual_port,sock) = open_any_tcp_port(accept_sock,8000) 
(0x1f40,TcpServer(listening))

julia> println(dec(actual_port))
8000

julia> After wait_connected
After wait_connected
After wait_connected
0x610x0d0x0a0x620x0d0x0a0x630x0d0x0aCaught exception EOFError()
Caught exception EOFError()
Segmentation fault

If you remove stop_reading(sock) in the exception handler in process_sock the seg fault goes away.

cc: @JeffBezanson , @loladiro

[vtjnash]

After receiving an EOF, the stream is closed and invalid for any further operations. The functions in base need to be better about checking the state of the stream before doing operations on them, to avoid this sort of behavior.

[amitmurthy]

FWIW, it does not happen when only one stream is active. I think a nice set of stress tests for IO and parallelism/concurrency is due.

[ViralBShah]

+1 on better stress tests.

I agree that functions in base need to be robust about using streams, but it should certainly be possible to avoid a segfault.

[vtjnash]

related to #1923

[vtjnash]

fixed