Revert "change setup_stdio default method to support any IO (#40780)" (#40971)

This reverts commit 59a9df1.

Author: vtjnash

base/cmd.jl

@@ -165,7 +165,6 @@ rawhandle(x::OS_HANDLE) = x
 if OS_HANDLE !== RawFD
     rawhandle(x::RawFD) = Libc._get_osfhandle(x)
 end
-setup_stdio(stdio::Union{DevNull,OS_HANDLE,RawFD}, ::Bool) = (stdio, false)
 
 const Redirectable = Union{IO, FileRedirect, RawFD, OS_HANDLE}
 const StdIOSet = NTuple{3, Redirectable}

base/filesystem.jl

@@ -42,7 +42,7 @@ import .Base:
     IOError, _UVError, _sizeof_uv_fs, check_open, close, eof, eventloop, fd, isopen,
     bytesavailable, position, read, read!, readavailable, seek, seekend, show,
     skip, stat, unsafe_read, unsafe_write, write, transcode, uv_error,
-    setup_stdio, rawhandle, OS_HANDLE, INVALID_OS_HANDLE, windowserror, filesize
+    rawhandle, OS_HANDLE, INVALID_OS_HANDLE, windowserror, filesize
 
 import .Base.RefValue
 
@@ -76,7 +76,6 @@ if OS_HANDLE !== RawFD
 end
 
 rawhandle(file::File) = file.handle
-setup_stdio(file::File, ::Bool) = (file, false)
 
 # Filesystem.open, not Base.open
 function open(path::AbstractString, flags::Integer, mode::Integer=0)

base/process.jl

@@ -74,28 +74,26 @@ const SpawnIOs = Vector{Any} # convenience name for readability
 # handle marshalling of `Cmd` arguments from Julia to C
 @noinline function _spawn_primitive(file, cmd::Cmd, stdio::SpawnIOs)
     loop = eventloop()
-    GC.@preserve stdio begin
-        iohandles = Tuple{Cint, UInt}[ # assuming little-endian layout
-            let h = rawhandle(io)
-                h === C_NULL     ? (0x00, UInt(0)) :
-                h isa OS_HANDLE  ? (0x02, UInt(cconvert(@static(Sys.iswindows() ? Ptr{Cvoid} : Cint), h))) :
-                h isa Ptr{Cvoid} ? (0x04, UInt(h)) :
-                error("invalid spawn handle $h from $io")
-            end
-            for io in stdio]
-        handle = Libc.malloc(_sizeof_uv_process)
-        disassociate_julia_struct(handle) # ensure that data field is set to C_NULL
-        err = ccall(:jl_spawn, Int32,
-                  (Cstring, Ptr{Cstring}, Ptr{Cvoid}, Ptr{Cvoid},
-                   Ptr{Tuple{Cint, UInt}}, Int,
-                   UInt32, Ptr{Cstring}, Cstring, Ptr{Cvoid}),
-            file, cmd.exec, loop, handle,
-            iohandles, length(iohandles),
-            cmd.flags,
-            cmd.env === nothing ? C_NULL : cmd.env,
-            isempty(cmd.dir) ? C_NULL : cmd.dir,
-            @cfunction(uv_return_spawn, Cvoid, (Ptr{Cvoid}, Int64, Int32)))
-    end
+    iohandles = Tuple{Cint, UInt}[ # assuming little-endian layout
+        let h = rawhandle(io)
+            h === C_NULL     ? (0x00, UInt(0)) :
+            h isa OS_HANDLE  ? (0x02, UInt(cconvert(@static(Sys.iswindows() ? Ptr{Cvoid} : Cint), h))) :
+            h isa Ptr{Cvoid} ? (0x04, UInt(h)) :
+            error("invalid spawn handle $h from $io")
+        end
+        for io in stdio]
+    handle = Libc.malloc(_sizeof_uv_process)
+    disassociate_julia_struct(handle) # ensure that data field is set to C_NULL
+    err = ccall(:jl_spawn, Int32,
+              (Cstring, Ptr{Cstring}, Ptr{Cvoid}, Ptr{Cvoid},
+               Ptr{Tuple{Cint, UInt}}, Int,
+               UInt32, Ptr{Cstring}, Cstring, Ptr{Cvoid}),
+        file, cmd.exec, loop, handle,
+        iohandles, length(iohandles),
+        cmd.flags,
+        cmd.env === nothing ? C_NULL : cmd.env,
+        isempty(cmd.dir) ? C_NULL : cmd.dir,
+        @cfunction(uv_return_spawn, Cvoid, (Ptr{Cvoid}, Int64, Int32)))
     if err != 0
         ccall(:jl_forceclose_uv, Cvoid, (Ptr{Cvoid},), handle) # will call free on handle eventually
         throw(_UVError("could not spawn " * repr(cmd), err))
@@ -211,10 +209,10 @@ function setup_stdio(stdio::PipeEndpoint, child_readable::Bool)
         rd, wr = link_pipe(!child_readable, child_readable)
         try
             open_pipe!(stdio, child_readable ? wr : rd)
-        catch
+        catch ex
             close_pipe_sync(rd)
             close_pipe_sync(wr)
-            rethrow()
+            rethrow(ex)
         end
         child = child_readable ? rd : wr
         return (child, true)
@@ -253,18 +251,18 @@ function setup_stdio(stdio::FileRedirect, child_readable::Bool)
     return (io, true)
 end
 
-# incrementally move data between an arbitrary IO and a system Pipe
+# incrementally move data between an IOBuffer and a system Pipe
 # TODO: probably more efficient (when valid) to use `stdio` directly as the
 #       PipeEndpoint buffer field in some cases
-function setup_stdio(stdio::IO, child_readable::Bool)
+function setup_stdio(stdio::Union{IOBuffer, BufferStream}, child_readable::Bool)
     parent = PipeEndpoint()
     rd, wr = link_pipe(!child_readable, child_readable)
     try
         open_pipe!(parent, child_readable ? wr : rd)
-    catch
+    catch ex
         close_pipe_sync(rd)
         close_pipe_sync(wr)
-        rethrow()
+        rethrow(ex)
     end
     child = child_readable ? rd : wr
     try
@@ -273,18 +271,24 @@ function setup_stdio(stdio::IO, child_readable::Bool)
             @async try
                 write(in, out)
             catch ex
-                @warn "Process I/O error" exception=(ex, catch_backtrace())
+                @warn "Process error" exception=(ex, catch_backtrace())
             finally
                 close(parent)
             end
         end
-    catch
+    catch ex
         close_pipe_sync(child)
-        rethrow()
+        rethrow(ex)
     end
     return (child, true)
 end
 
+function setup_stdio(io, child_readable::Bool)
+    # if there is no specialization,
+    # assume that rawhandle is defined for it
+    return (io, false)
+end
+
 close_stdio(stdio::OS_HANDLE) = close_pipe_sync(stdio)
 close_stdio(stdio) = close(stdio)
 

base/stream.jl

@@ -282,7 +282,6 @@ end
 lock(s::LibuvStream) = lock(s.lock)
 unlock(s::LibuvStream) = unlock(s.lock)
 
-setup_stdio(stream::LibuvStream) = (stream, false)
 rawhandle(stream::LibuvStream) = stream.handle
 unsafe_convert(::Type{Ptr{Cvoid}}, s::Union{LibuvStream, LibuvServer}) = s.handle
 

test/spawn.jl

@@ -697,15 +697,7 @@ let text = "input-test-text"
     @test read(proc, String) == string(length(text), '\n')
     @test success(proc)
     @test String(take!(b)) == text
-
-    out = PipeBuffer()
-    proc = run(catcmd, IOBuffer(SubString(text)), out)
-    @test success(proc)
-    @test proc.out === proc.err === proc.in === devnull
-    @test String(take!(out)) == text
 end
-
-
 @test repr(Base.CmdRedirect(``, devnull, 0, false)) == "pipeline(``, stdin>Base.DevNull())"
 @test repr(Base.CmdRedirect(``, devnull, 1, true)) == "pipeline(``, stdout<Base.DevNull())"
 @test repr(Base.CmdRedirect(``, devnull, 11, true)) == "pipeline(``, 11<Base.DevNull())"