[release-branch.go1.20] runtime: change fcntl to return two values

Separate the result and the errno value, rather than assuming
that the result can never be negative.

Change-Id: Ib01a70a3d46285aa77e95371cdde74e1504e7c12
Reviewed-on: https://go-review.googlesource.com/c/go/+/496416
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
Auto-Submit: Ian Lance Taylor <iant@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/497116
Run-TryBot: Roland Shoemaker <roland@golang.org>
Auto-Submit: Heschi Kreinick <heschi@google.com>

diff --git a/src/runtime/nbpipe_test.go b/src/runtime/nbpipe_test.go
index bb21003c358239f141254bcab3aa4c8791156dfa..337b8e591412f7808f5a5a57080fc93c121f2c56 100644 (file)
--- a/src/runtime/nbpipe_test.go
+++ b/src/runtime/nbpipe_test.go
@@ -31,11 +31,11 @@ func TestNonblockingPipe(t *testing.T) {
        if runtime.Close(r) != 0 {
                t.Fatalf("Close(%d) failed", r)
        }
-       val := runtime.Fcntl(r, syscall.F_GETFD, 0)
-       if val >= 0 {
+       val, errno := runtime.Fcntl(r, syscall.F_GETFD, 0)
+       if val != -1 {
                t.Errorf("Fcntl succeeded unexpectedly")
-       } else if syscall.Errno(-val) != syscall.EBADF {
-               t.Errorf("Fcntl failed with error %v, expected %v", -val, syscall.EBADF)
+       } else if syscall.Errno(errno) != syscall.EBADF {
+               t.Errorf("Fcntl failed with error %v, expected %v", syscall.Errno(errno), syscall.EBADF)
        }
 }
 
@@ -55,9 +55,9 @@ func checkIsPipe(t *testing.T, r, w int32) {
 
 func checkNonblocking(t *testing.T, fd int32, name string) {
        t.Helper()
-       flags := runtime.Fcntl(fd, syscall.F_GETFL, 0)
-       if flags < 0 {
-               t.Errorf("fcntl(%s, F_GETFL) failed: %v", name, syscall.Errno(-flags))
+       flags, errno := runtime.Fcntl(fd, syscall.F_GETFL, 0)
+       if flags == -1 {
+               t.Errorf("fcntl(%s, F_GETFL) failed: %v", name, syscall.Errno(errno))
        } else if flags&syscall.O_NONBLOCK == 0 {
                t.Errorf("O_NONBLOCK not set in %s flags %#x", name, flags)
        }
@@ -65,9 +65,9 @@ func checkNonblocking(t *testing.T, fd int32, name string) {
 
 func checkCloseonexec(t *testing.T, fd int32, name string) {
        t.Helper()
-       flags := runtime.Fcntl(fd, syscall.F_GETFD, 0)
-       if flags < 0 {
-               t.Errorf("fcntl(%s, F_GETFD) failed: %v", name, syscall.Errno(flags))
+       flags, errno := runtime.Fcntl(fd, syscall.F_GETFD, 0)
+       if flags == -1 {
+               t.Errorf("fcntl(%s, F_GETFD) failed: %v", name, syscall.Errno(errno))
        } else if flags&syscall.FD_CLOEXEC == 0 {
                t.Errorf("FD_CLOEXEC not set in %s flags %#x", name, flags)
        }

diff --git a/src/runtime/os3_solaris.go b/src/runtime/os3_solaris.go
index 219e02d8351b581fad4c0ce336f0b779ba18e15f..44ea7a27c62ca196e4775531b4b788853e150537 100644 (file)
--- a/src/runtime/os3_solaris.go
+++ b/src/runtime/os3_solaris.go
@@ -570,12 +570,9 @@ func pipe2(flags int32) (r, w int32, errno int32) {
 }
 
 //go:nosplit
-func fcntl(fd, cmd, arg int32) int32 {
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32) {
        r1, err := sysvicall3Err(&libc_fcntl, uintptr(fd), uintptr(cmd), uintptr(arg))
-       if r := int32(r1); r >= 0 {
-               return r
-       }
-       return -int32(err)
+       return int32(r1), int32(err)
 }
 
 //go:nosplit

diff --git a/src/runtime/os_aix.go b/src/runtime/os_aix.go
index 56b77e955a08fe2e868f58601fcac38fb620cecd..7845de1470776f38fc4cbd8213ff0a65276d3635 100644 (file)
--- a/src/runtime/os_aix.go
+++ b/src/runtime/os_aix.go
@@ -352,12 +352,9 @@ func walltime() (sec int64, nsec int32) {
 }
 
 //go:nosplit
-func fcntl(fd, cmd, arg int32) int32 {
+func fcntl(fd, cmd, arg int32) (int32, int32) {
        r, errno := syscall3(&libc_fcntl, uintptr(fd), uintptr(cmd), uintptr(arg))
-       if int32(r) < 0 {
-               return -int32(errno)
-       }
-       return int32(r)
+       return int32(r), int32(errno)
 }
 
 //go:nosplit
@@ -367,8 +364,10 @@ func closeonexec(fd int32) {
 
 //go:nosplit
 func setNonblock(fd int32) {
-       flags := fcntl(fd, _F_GETFL, 0)
-       fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
+       flags, _ := fcntl(fd, _F_GETFL, 0)
+       if flags != -1 {
+               fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
+       }
 }
 
 // sigPerThreadSyscall is only used on linux, so we assign a bogus signal

diff --git a/src/runtime/os_dragonfly.go b/src/runtime/os_dragonfly.go
index ff73e0683a78a1834be72442b3251eb5efcd1e2b..460dc88abec4467987656c04d1c191d889143130 100644 (file)
--- a/src/runtime/os_dragonfly.go
+++ b/src/runtime/os_dragonfly.go
@@ -63,7 +63,7 @@ func kqueue() int32
 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
 
 func pipe2(flags int32) (r, w int32, errno int32)
-func fcntl(fd, cmd, arg int32) int32
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32)
 func closeonexec(fd int32)
 
 // From DragonFly's <sys/sysctl.h>

diff --git a/src/runtime/os_freebsd.go b/src/runtime/os_freebsd.go
index efc44c16e9938743a902c7579c178dba1c1b05f1..e77507b70d1cc1d6b3f89fbaee29879d7da4a965 100644 (file)
--- a/src/runtime/os_freebsd.go
+++ b/src/runtime/os_freebsd.go
@@ -48,7 +48,7 @@ func kqueue() int32
 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
 
 func pipe2(flags int32) (r, w int32, errno int32)
-func fcntl(fd, cmd, arg int32) int32
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32)
 func closeonexec(fd int32)
 
 // From FreeBSD's <sys/sysctl.h>

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index a7d2cc5becccc2033db55db2eabd20bd5af4bae4..e2581fba6548b35c2f9cf58da1b679b802156afb 100644 (file)
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -462,13 +462,9 @@ func osyield_no_g() {
 func pipe2(flags int32) (r, w int32, errno int32)
 
 //go:nosplit
-func fcntl(fd, cmd, arg int32) int32 {
-       r, _, errno := syscall.Syscall6(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
-       ri := int32(r)
-       if ri < 0 {
-               return -int32(errno)
-       }
-       return ri
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32) {
+       r, _, err := syscall.Syscall6(syscall.SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
+       return int32(r), int32(err)
 }
 
 const (

diff --git a/src/runtime/os_netbsd.go b/src/runtime/os_netbsd.go
index d56e0e36acbc0d6c2265578d2a74a562538b1afe..d77855ec0cdd80796dd15be8f99cb9867b4e6bd5 100644 (file)
--- a/src/runtime/os_netbsd.go
+++ b/src/runtime/os_netbsd.go
@@ -79,7 +79,7 @@ func kqueue() int32
 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
 
 func pipe2(flags int32) (r, w int32, errno int32)
-func fcntl(fd, cmd, arg int32) int32
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32)
 func closeonexec(fd int32)
 
 const (

diff --git a/src/runtime/os_openbsd_syscall2.go b/src/runtime/os_openbsd_syscall2.go
index 0b61773c9d2edb3382ab5f431bfacd59ce3cd95c..dcf3b09e6780a86724e96aeb3d072c94cfceb320 100644 (file)
--- a/src/runtime/os_openbsd_syscall2.go
+++ b/src/runtime/os_openbsd_syscall2.go
@@ -95,7 +95,7 @@ func nanotime1() int64
 //go:noescape
 func sigaltstack(new, old *stackt)
 
-func fcntl(fd, cmd, arg int32) int32
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32)
 func closeonexec(fd int32)
 
 func walltime() (sec int64, nsec int32)

diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index 5ba697e3047f467a64a05372afe500b6c09b7f28..a56a9373b95cbedbb3d0c376c0f3af923714e077 100644 (file)
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -434,8 +434,13 @@ func sysctlbyname_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
-func fcntl(fd, cmd, arg int32) int32 {
-       return libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&fd))
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32) {
+       args := struct {
+               fd, cmd, arg int32
+               ret, errno   int32
+       }{fd, cmd, arg, 0, 0}
+       libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&args))
+       return args.ret, args.errno
 }
 func fcntl_trampoline()
 
@@ -538,8 +543,10 @@ func closeonexec(fd int32) {
 
 //go:nosplit
 func setNonblock(fd int32) {
-       flags := fcntl(fd, _F_GETFL, 0)
-       fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
+       flags, _ := fcntl(fd, _F_GETFL, 0)
+       if flags != -1 {
+               fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
+       }
 }
 
 // Tell the linker that the libc_* functions are to be found

diff --git a/src/runtime/sys_darwin_amd64.s b/src/runtime/sys_darwin_amd64.s
index e97811c9abc4bd77c1326eed1bfff6bbad1ae608..2a2aeff77d19f437944da3316c608170ba1984ae 100644 (file)
--- a/src/runtime/sys_darwin_amd64.s
+++ b/src/runtime/sys_darwin_amd64.s
@@ -432,17 +432,21 @@ ok:
 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
-       MOVL    4(DI), SI               // arg 2 cmd
-       MOVL    8(DI), DX               // arg 3 arg
-       MOVL    0(DI), DI               // arg 1 fd
+       MOVQ    DI, BX
+       MOVL    0(BX), DI               // arg 1 fd
+       MOVL    4(BX), SI               // arg 2 cmd
+       MOVL    8(BX), DX               // arg 3 arg
        XORL    AX, AX                  // vararg: say "no float args"
        CALL    libc_fcntl(SB)
-       TESTL   AX, AX
-       JGT     noerr
+       XORL    DX, DX
+       CMPQ    AX, $-1
+       JNE     noerr
        CALL    libc_error(SB)
-       MOVL    (AX), AX
-       NEGL    AX                      // caller expects negative errno value
+       MOVL    (AX), DX
+       MOVL    $-1, AX
 noerr:
+       MOVL    AX, 12(BX)
+       MOVL    DX, 16(BX)
        POPQ    BP
        RET
 

diff --git a/src/runtime/sys_darwin_arm64.s b/src/runtime/sys_darwin_arm64.s
index 4111b3427bd5564c2069e876b01e4bb5183f382c..e1c61fae55ba105ef110dc67052ce0ec390b5ed1 100644 (file)
--- a/src/runtime/sys_darwin_arm64.s
+++ b/src/runtime/sys_darwin_arm64.s
@@ -309,18 +309,22 @@ ok:
 
 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
        SUB     $16, RSP
-       MOVW    4(R0), R1       // arg 2 cmd
-       MOVW    8(R0), R2       // arg 3 arg
+       MOVD    R0, R19
+       MOVW    0(R19), R0      // arg 1 fd
+       MOVW    4(R19), R1      // arg 2 cmd
+       MOVW    8(R19), R2      // arg 3 arg
        MOVW    R2, (RSP)       // arg 3 is variadic, pass on stack
-       MOVW    0(R0), R0       // arg 1 fd
        BL      libc_fcntl(SB)
-       MOVD    $-1, R1
-       CMP     R0, R1
+       MOVD    $0, R1
+       MOVD    $-1, R2
+       CMP     R0, R2
        BNE     noerr
        BL      libc_error(SB)
-       MOVW    (R0), R0
-       NEG     R0, R0          // caller expects negative errno value
+       MOVW    (R0), R1
+       MOVW    $-1, R0
 noerr:
+       MOVW    R0, 12(R19)
+       MOVW    R1, 16(R19)
        ADD     $16, RSP
        RET
 

diff --git a/src/runtime/sys_dragonfly_amd64.s b/src/runtime/sys_dragonfly_amd64.s
index e3d85ab062acc8546b7f9eef7fb1290302daf478..958d712cd3d707ff45ae3ddbcbe6e315b4ab3d79 100644 (file)
--- a/src/runtime/sys_dragonfly_amd64.s
+++ b/src/runtime/sys_dragonfly_amd64.s
@@ -387,16 +387,20 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVL    AX, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (ret int32, errno int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVL    fd+0(FP), DI    // fd
        MOVL    cmd+4(FP), SI   // cmd
        MOVL    arg+8(FP), DX   // arg
        MOVL    $92, AX         // fcntl
        SYSCALL
-       JCC     2(PC)
-       NEGL    AX              // caller expects negative errno
+       JCC     noerr
+       MOVL    $-1, ret+16(FP)
+       MOVL    AX, errno+20(FP)
+       RET
+noerr:
        MOVL    AX, ret+16(FP)
+       MOVL    $0, errno+20(FP)
        RET
 
 // void runtime·closeonexec(int32 fd);

diff --git a/src/runtime/sys_freebsd_386.s b/src/runtime/sys_freebsd_386.s
index 55c299f36f75b431d740452f7d1bd0f942fb4a77..a5a668cb7003c521d8a11109e7065d0b1c280eee 100644 (file)
--- a/src/runtime/sys_freebsd_386.s
+++ b/src/runtime/sys_freebsd_386.s
@@ -451,13 +451,17 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVL    AX, ret+24(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$-4
        MOVL    $SYS_fcntl, AX
        INT     $0x80
-       JAE     2(PC)
-       NEGL    AX                      // caller expects negative errno
+       JAE     noerr
+       MOVL    $-1, ret+12(FP)
+       MOVL    AX, errno+16(FP)
+       RET
+noerr:
        MOVL    AX, ret+12(FP)
+       MOVL    $0, errno+16(FP)
        RET
 
 // int32 runtime·closeonexec(int32 fd);

diff --git a/src/runtime/sys_freebsd_amd64.s b/src/runtime/sys_freebsd_amd64.s
index cd4029a72dd19a42fbb63c46d8d8ac48bec13047..bd3c60ec19cc514c1be005fde8bb54e1e9b6247c 100644 (file)
--- a/src/runtime/sys_freebsd_amd64.s
+++ b/src/runtime/sys_freebsd_amd64.s
@@ -550,16 +550,20 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVL    AX, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVL    fd+0(FP), DI    // fd
        MOVL    cmd+4(FP), SI   // cmd
        MOVL    arg+8(FP), DX   // arg
        MOVL    $SYS_fcntl, AX
        SYSCALL
-       JCC     2(PC)
-       NEGQ    AX              // caller expects negative errno
+       JCC     noerr
+       MOVL    $-1, ret+16(FP)
+       MOVL    AX, errno+20(FP)
+       RET
+noerr:
        MOVL    AX, ret+16(FP)
+       MOVL    $0, errno+20(FP)
        RET
 
 // void runtime·closeonexec(int32 fd);

diff --git a/src/runtime/sys_freebsd_arm.s b/src/runtime/sys_freebsd_arm.s
index 2da092ad8ea09cf8194886882aff506592bb84b2..9b09d9d349fec6dd1ebc52ff1b52218779efd994 100644 (file)
--- a/src/runtime/sys_freebsd_arm.s
+++ b/src/runtime/sys_freebsd_arm.s
@@ -387,15 +387,18 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVW    R0, ret+24(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVW fd+0(FP), R0       // fd
        MOVW cmd+4(FP), R1      // cmd
        MOVW arg+8(FP), R2      // arg
        MOVW $SYS_fcntl, R7
        SWI $0
-       RSB.CS $0, R0           // caller expects negative errno
+       MOVW $0, R1
+       MOVW.CS R0, R1
+       MOVW.CS $-1, R0
        MOVW R0, ret+12(FP)
+       MOVW R1, errno+16(FP)
        RET
 
 // void runtime·closeonexec(int32 fd)

diff --git a/src/runtime/sys_freebsd_arm64.s b/src/runtime/sys_freebsd_arm64.s
index 6fb07bbd08d94a90e7643da159efc9d0795e9ac5..36c106088e0d712a051b9a53dad8c8a79c572280 100644 (file)
--- a/src/runtime/sys_freebsd_arm64.s
+++ b/src/runtime/sys_freebsd_arm64.s
@@ -444,17 +444,21 @@ ok:
        MOVW    R0, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVW    fd+0(FP), R0
        MOVW    cmd+4(FP), R1
        MOVW    arg+8(FP), R2
        MOVD    $SYS_fcntl, R8
        SVC
-       BCC     ok
-       NEG     R0, R0          // caller expects negative errno
-ok:
+       BCC     noerr
+       MOVW    $-1, R1
+       MOVW    R1, ret+16(FP)
+       MOVW    R0, errno+20(FP)
+       RET
+noerr:
        MOVW    R0, ret+16(FP)
+       MOVW    $0, errno+20(FP)
        RET
 
 // func closeonexec(fd int32)

diff --git a/src/runtime/sys_freebsd_riscv64.s b/src/runtime/sys_freebsd_riscv64.s
index 0d3a0a83fb8b3377feb2946efff3ca6d8203761b..58173c2cb64cd00ae3e72a6294c232959895cca3 100644 (file)
--- a/src/runtime/sys_freebsd_riscv64.s
+++ b/src/runtime/sys_freebsd_riscv64.s
@@ -420,17 +420,21 @@ ok:
        MOVW    A0, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVW    fd+0(FP), A0
        MOVW    cmd+4(FP), A1
        MOVW    arg+8(FP), A2
        MOV     $SYS_fcntl, T0
        ECALL
-       BEQ     T0, ZERO, ok
-       NEG     A0, A0          // caller expects negative errno
-ok:
+       BEQ     T0, ZERO, noerr
+       MOV     $-1, A1
+       MOVW    A1, ret+16(FP)
+       MOVW    A0, errno+20(FP)
+       RET
+noerr:
        MOVW    A0, ret+16(FP)
+       MOVW    ZERO, errno+20(FP)
        RET
 
 // func closeonexec(fd int32)

diff --git a/src/runtime/sys_netbsd_386.s b/src/runtime/sys_netbsd_386.s
index a05e1d44787294c4480a8a7a1aaa47bd9c2ccc29..e649fb13cbbbb9f762883aa739dc0344b97a3604 100644 (file)
--- a/src/runtime/sys_netbsd_386.s
+++ b/src/runtime/sys_netbsd_386.s
@@ -457,13 +457,17 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVL    AX, ret+24(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$-4
        MOVL    $SYS_fcntl, AX
        INT     $0x80
-       JAE     2(PC)
-       NEGL    AX                      // caller expects negative errno
+       JAE     noerr
+       MOVL    $-1, ret+12(FP)
+       MOVL    AX, errno+16(FP)
+       RET
+noerr:
        MOVL    AX, ret+12(FP)
+       MOVL    $0, errno+16(FP)
        RET
 
 // int32 runtime·closeonexec(int32 fd)

diff --git a/src/runtime/sys_netbsd_amd64.s b/src/runtime/sys_netbsd_amd64.s
index 368eef56edf5929331326a1ce295da875910e011..2c2d97c10545187f0379da518d7b4ccc6e97741d 100644 (file)
--- a/src/runtime/sys_netbsd_amd64.s
+++ b/src/runtime/sys_netbsd_amd64.s
@@ -434,16 +434,20 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVL    AX, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int2
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVL    fd+0(FP), DI    // fd
        MOVL    cmd+4(FP), SI   // cmd
        MOVL    arg+8(FP), DX   // arg
        MOVL    $SYS_fcntl, AX
        SYSCALL
-       JCC     2(PC)
-       NEGQ    AX              // caller expects negative errno
+       JCC     noerr
+       MOVL    $-1, ret+16(FP)
+       MOVL    AX, errno+20(FP)
+       RET
+noerr:
        MOVL    AX, ret+16(FP)
+       MOVL    $0, errno+20(FP)
        RET
 
 // void runtime·closeonexec(int32 fd)

diff --git a/src/runtime/sys_netbsd_arm.s b/src/runtime/sys_netbsd_arm.s
index f9cbcb6df1bdcd3a8bb189cbd36410e479a242fa..9d969592c47da949a1ac8809ea0887bc58853de4 100644 (file)
--- a/src/runtime/sys_netbsd_arm.s
+++ b/src/runtime/sys_netbsd_arm.s
@@ -404,8 +404,11 @@ TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVW cmd+4(FP), R1
        MOVW arg+8(FP), R2
        SWI $SYS_fcntl
-       RSB.CS $0, R0           // caller expects negative errno
+       MOVW $0, R1
+       MOVW.CS R0, R1
+       MOVW.CS $-1, R0
        MOVW R0, ret+12(FP)
+       MOVW R1, errno+16(FP)
        RET
 
 // void runtime·closeonexec(int32 fd)

diff --git a/src/runtime/sys_netbsd_arm64.s b/src/runtime/sys_netbsd_arm64.s
index d27133550a877d984b847ed0e06e02cc7900c2ce..0cd9262750f8fb6ac3d0ddb590cea2032144c5ed 100644 (file)
--- a/src/runtime/sys_netbsd_arm64.s
+++ b/src/runtime/sys_netbsd_arm64.s
@@ -421,16 +421,20 @@ ok:
        MOVW    R0, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVW    fd+0(FP), R0    // fd
        MOVW    cmd+4(FP), R1   // cmd
        MOVW    arg+8(FP), R2   // arg
        SVC     $SYS_fcntl
-       BCC     ok
-       NEG     R0, R0          // caller expects negative errno
-ok:
+       BCC     noerr
+       MOVW    $-1, R1
+       MOVW    R1, ret+16(FP)
+       MOVW    R0, errno+20(FP)
+       RET
+noerr:
        MOVW    R0, ret+16(FP)
+       MOVW    $0, errno+20(FP)
        RET
 
 // void runtime·closeonexec(int32 fd)

diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index 49bad8ed1d68cfff7c53cc1fadb02192059ac987..12a53dfc6d95ecd2eee5f1768b604cdeb4d2d461 100644 (file)
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -161,8 +161,13 @@ func sysctl_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
-func fcntl(fd, cmd, arg int32) int32 {
-       return libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&fd))
+func fcntl(fd, cmd, arg int32) (ret int32, errno int32) {
+       args := struct {
+               fd, cmd, arg int32
+               ret, errno   int32
+       }{fd, cmd, arg, 0, 0}
+       libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&args))
+       return args.ret, args.errno
 }
 func fcntl_trampoline()
 

diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index 3e5dbc2b0a8496aa81c4a7f75c1d79ebb58e3f34..d0d9926ff91ade3ef48b6031f99feb0ee7e5a559 100644 (file)
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -542,12 +542,16 @@ TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
        MOVL    CX, 8(SP)               // arg 3 - arg
        MOVL    $0, 12(SP)              // vararg
        CALL    libc_fcntl(SB)
+       MOVL    $0, BX
        CMPL    AX, $-1
        JNE     noerr
        CALL    libc_errno(SB)
-       MOVL    (AX), AX
-       NEGL    AX                      // caller expects negative errno
+       MOVL    (AX), BX
+       MOVL    $-1, AX
 noerr:
+       MOVL    24(SP), DX              // pointer to args
+       MOVL    AX, 12(DX)
+       MOVL    BX, 16(DX)
        MOVL    BP, SP
        POPL    BP
        RET

diff --git a/src/runtime/sys_openbsd_amd64.s b/src/runtime/sys_openbsd_amd64.s
index 35a57c026b6501a228effd77fd9ecb576d3a54c5..893a92e26f16733c0d360d9dac4127dc0f3b3de0 100644 (file)
--- a/src/runtime/sys_openbsd_amd64.s
+++ b/src/runtime/sys_openbsd_amd64.s
@@ -388,17 +388,21 @@ noerr:
 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
        PUSHQ   BP
        MOVQ    SP, BP
-       MOVL    4(DI), SI               // arg 2 cmd
-       MOVL    8(DI), DX               // arg 3 arg
-       MOVL    0(DI), DI               // arg 1 fd
+       MOVQ    DI, BX
+       MOVL    0(BX), DI               // arg 1 fd
+       MOVL    4(BX), SI               // arg 2 cmd
+       MOVL    8(BX), DX               // arg 3 arg
        XORL    AX, AX                  // vararg: say "no float args"
        CALL    libc_fcntl(SB)
-       TESTL   AX, AX
-       JGE     noerr
+       XORL    DX, DX
+       CMPL    AX, $-1
+       JNE     noerr
        CALL    libc_errno(SB)
-       MOVL    (AX), AX
-       NEGL    AX                      // caller expects negative errno value
+       MOVL    (AX), DX
+       MOVL    $-1, AX
 noerr:
+       MOVL    AX, 12(BX)
+       MOVL    DX, 16(BX)
        POPQ    BP
        RET
 

diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 3568d4eb941692e70c210744f4ab1a582c5f131a..fc04cf11a4c094cae570f187bbbab491379e75af 100644 (file)
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -419,17 +419,21 @@ TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
        MOVW    R13, R9
        SUB     $8, R13
        BIC     $0x7, R13               // align for ELF ABI
-       MOVW    4(R0), R1               // arg 2 cmd
-       MOVW    8(R0), R2               // arg 3 arg (vararg, on stack)
+       MOVW    R0, R8
+       MOVW    0(R8), R0               // arg 1 fd
+       MOVW    4(R8), R1               // arg 2 cmd
+       MOVW    8(R8), R2               // arg 3 arg (vararg, on stack)
        MOVW    R2, 0(R13)
-       MOVW    0(R0), R0               // arg 1 fd
        BL      libc_fcntl(SB)
+       MOVW    $0, R1
        CMP     $-1, R0
        BNE     noerr
        BL      libc_errno(SB)
-       MOVW    (R0), R0
-       RSB.CS  $0, R0                  // caller expects negative errno
+       MOVW    (R0), R1
+       MOVW    $-1, R0
 noerr:
+       MOVW    R0, 12(R8)
+       MOVW    R1, 16(R8)
        MOVW    R9, R13
        RET
 

diff --git a/src/runtime/sys_openbsd_arm64.s b/src/runtime/sys_openbsd_arm64.s
index 0bd801ff7a98e6df248c6e8ac6a8759f524d1b3b..c40889861a8ad7dd17aa6fb659881e8db2bad7e4 100644 (file)
--- a/src/runtime/sys_openbsd_arm64.s
+++ b/src/runtime/sys_openbsd_arm64.s
@@ -306,17 +306,21 @@ noerr:
        RET
 
 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
-       MOVW    4(R0), R1               // arg 2 - cmd
-       MOVW    8(R0), R2               // arg 3 - arg
-       MOVW    0(R0), R0               // arg 1 - fd
+       MOVD    R0, R19
+       MOVW    0(R19), R0              // arg 1 - fd
+       MOVW    4(R19), R1              // arg 2 - cmd
+       MOVW    8(R19), R2              // arg 3 - arg
        MOVD    $0, R3                  // vararg
        CALL    libc_fcntl(SB)
+       MOVD    $0, R1
        CMP     $-1, R0
        BNE     noerr
        CALL    libc_errno(SB)
-       MOVW    (R0), R0
-       NEG     R0, R0                  // caller expects negative errno value
+       MOVW    (R0), R1
+       MOVW    $-1, R0
 noerr:
+       MOVW    R0, 12(R19)
+       MOVW    R1, 16(R19)
        RET
 
 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0

diff --git a/src/runtime/sys_openbsd_mips64.s b/src/runtime/sys_openbsd_mips64.s
index 0ba53cd37d5e68805085c2a605264171e9d24bb3..9238e7d0b0efa0c6b96238085779760b31f38d41 100644 (file)
--- a/src/runtime/sys_openbsd_mips64.s
+++ b/src/runtime/sys_openbsd_mips64.s
@@ -364,16 +364,20 @@ TEXT runtime·kevent(SB),NOSPLIT,$0
        MOVW    R2, ret+48(FP)
        RET
 
-// func fcntl(fd, cmd, arg int32) int32
+// func fcntl(fd, cmd, arg int32) (int32, int32)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
        MOVW    fd+0(FP), R4    // fd
        MOVW    cmd+4(FP), R5   // cmd
        MOVW    arg+8(FP), R6   // arg
        MOVV    $92, R2         // sys_fcntl
        SYSCALL
-       BEQ     R7, 2(PC)
-       SUBVU   R2, R0, R2      // caller expects negative errno
+       MOVV    $0, R4
+       BEQ     R7, noerr
+       MOVV    R2, R4
+       MOVW    $-1, R2
+noerr:
        MOVW    R2, ret+16(FP)
+       MOVW    R4, errno+20(FP)
        RET
 
 // func closeonexec(fd int32)