diff options
Diffstat (limited to 'src/pkg/syscall')
136 files changed, 11284 insertions, 1281 deletions
diff --git a/src/pkg/syscall/asm_darwin_386.s b/src/pkg/syscall/asm_darwin_386.s index 2ddfb3bbd..9b4dfa81d 100644 --- a/src/pkg/syscall/asm_darwin_386.s +++ b/src/pkg/syscall/asm_darwin_386.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -12,7 +15,7 @@ // func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32); // Trap # in AX, args on stack above caller pc. -TEXT ·Syscall(SB),NOSPLIT,$0-32 +TEXT ·Syscall(SB),NOSPLIT,$0-28 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-44 +TEXT ·Syscall6(SB),NOSPLIT,$0-40 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -63,7 +66,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-56 +TEXT ·Syscall9(SB),NOSPLIT,$0-52 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -93,7 +96,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-32 +TEXT ·RawSyscall(SB),NOSPLIT,$0-28 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI @@ -114,7 +117,7 @@ ok1: MOVL $0, 28(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI diff --git a/src/pkg/syscall/asm_darwin_amd64.s b/src/pkg/syscall/asm_darwin_amd64.s index c1970b71d..19ea05be7 100644 --- a/src/pkg/syscall/asm_darwin_amd64.s +++ b/src/pkg/syscall/asm_darwin_amd64.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -12,7 +15,7 @@ // func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64); // Trap # in AX, args in DI SI DX, return in AX DX -TEXT ·Syscall(SB),NOSPLIT,$0-64 +TEXT ·Syscall(SB),NOSPLIT,$0-56 CALL runtime·entersyscall(SB) MOVQ 16(SP), DI MOVQ 24(SP), SI @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-88 +TEXT ·Syscall6(SB),NOSPLIT,$0-80 CALL runtime·entersyscall(SB) MOVQ 16(SP), DI MOVQ 24(SP), SI @@ -60,7 +63,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-64 +TEXT ·RawSyscall(SB),NOSPLIT,$0-56 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX @@ -81,7 +84,7 @@ ok1: MOVQ $0, 56(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX diff --git a/src/pkg/syscall/asm_freebsd_386.s b/src/pkg/syscall/asm_freebsd_386.s index d24216fdd..91a46b106 100644 --- a/src/pkg/syscall/asm_freebsd_386.s +++ b/src/pkg/syscall/asm_freebsd_386.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -12,7 +15,7 @@ // func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32); // Trap # in AX, args on stack above caller pc. -TEXT ·Syscall(SB),NOSPLIT,$0-32 +TEXT ·Syscall(SB),NOSPLIT,$0-28 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-44 +TEXT ·Syscall6(SB),NOSPLIT,$0-40 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -63,7 +66,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-56 +TEXT ·Syscall9(SB),NOSPLIT,$0-52 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -93,7 +96,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-32 +TEXT ·RawSyscall(SB),NOSPLIT,$0-28 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI @@ -114,7 +117,7 @@ ok1: MOVL $0, 28(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI diff --git a/src/pkg/syscall/asm_freebsd_amd64.s b/src/pkg/syscall/asm_freebsd_amd64.s index fca7f371e..7abb36828 100644 --- a/src/pkg/syscall/asm_freebsd_amd64.s +++ b/src/pkg/syscall/asm_freebsd_amd64.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -18,7 +21,7 @@ // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64) // Trap # in AX, args in DI SI DX, return in AX DX -TEXT ·Syscall(SB),NOSPLIT,$0-64 +TEXT ·Syscall(SB),NOSPLIT,$0-56 CALL runtime·entersyscall(SB) MOVQ 16(SP), DI MOVQ 24(SP), SI @@ -41,7 +44,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-88 +TEXT ·Syscall6(SB),NOSPLIT,$0-80 CALL runtime·entersyscall(SB) MOVQ 16(SP), DI MOVQ 24(SP), SI @@ -64,7 +67,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-112 +TEXT ·Syscall9(SB),NOSPLIT,$0-104 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX MOVQ 16(SP), DI @@ -97,7 +100,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-64 +TEXT ·RawSyscall(SB),NOSPLIT,$0-56 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX @@ -117,7 +120,7 @@ ok1: MOVQ $0, 56(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX diff --git a/src/pkg/syscall/asm_freebsd_arm.s b/src/pkg/syscall/asm_freebsd_arm.s index 9283d079b..c01ce6feb 100644 --- a/src/pkg/syscall/asm_freebsd_arm.s +++ b/src/pkg/syscall/asm_freebsd_arm.s @@ -8,13 +8,13 @@ // System call support for ARM, FreeBSD // -// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32); -// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32); -// func Syscall9(trap int32, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int32) +// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, errno uintptr); +// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr); +// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, errno uintptr) TEXT ·Syscall(SB),NOSPLIT,$0-28 BL runtime·entersyscall(SB) - MOVW 0(FP), R7 // sigcall num + MOVW 0(FP), R7 // syscall number MOVW 4(FP), R0 // a1 MOVW 8(FP), R1 // a2 MOVW 12(FP), R2 // a3 @@ -23,69 +23,71 @@ TEXT ·Syscall(SB),NOSPLIT,$0-28 BCS error MOVW R0, 16(FP) // r1 MOVW R1, 20(FP) // r2 - MOVW R2, 24(FP) // err + MOVW R2, 24(FP) // errno BL runtime·exitsyscall(SB) RET error: MOVW $-1, R3 MOVW R3, 16(FP) // r1 MOVW R2, 20(FP) // r2 - MOVW R0, 24(FP) // err + MOVW R0, 24(FP) // errno BL runtime·exitsyscall(SB) RET TEXT ·Syscall6(SB),NOSPLIT,$0-40 BL runtime·entersyscall(SB) - MOVW 0(FP), R7 // sigcall num + MOVW 0(FP), R7 // syscall number MOVW 4(FP), R0 // a1 MOVW 8(FP), R1 // a2 MOVW 12(FP), R2 // a3 MOVW 16(FP), R3 // a4 - ADD $24, R13 // a5 to a6 are passed on stack + MOVW R13, R4 + MOVW $20(FP), R13 // a5 to a6 are passed on stack SWI $0 // syscall - SUB $24, R13 + MOVW R4, R13 MOVW $0, R2 BCS error6 MOVW R0, 28(FP) // r1 MOVW R1, 32(FP) // r2 - MOVW R2, 36(FP) // err + MOVW R2, 36(FP) // errno BL runtime·exitsyscall(SB) RET error6: MOVW $-1, R3 MOVW R3, 28(FP) // r1 MOVW R2, 32(FP) // r2 - MOVW R0, 36(FP) // err + MOVW R0, 36(FP) // errno BL runtime·exitsyscall(SB) RET TEXT ·Syscall9(SB),NOSPLIT,$0-52 BL runtime·entersyscall(SB) - MOVW 0(FP), R7 // sigcall num + MOVW 0(FP), R7 // syscall number MOVW 4(FP), R0 // a1 MOVW 8(FP), R1 // a2 MOVW 12(FP), R2 // a3 MOVW 16(FP), R3 // a4 - ADD $24, R13 // a5 to a9 are passed on stack + MOVW R13, R4 + MOVW $20(FP), R13 // a5 to a9 are passed on stack SWI $0 // syscall - SUB $24, R13 + MOVW R4, R13 MOVW $0, R2 BCS error9 MOVW R0, 40(FP) // r1 MOVW R1, 44(FP) // r2 - MOVW R2, 48(FP) // err + MOVW R2, 48(FP) // errno BL runtime·exitsyscall(SB) RET error9: MOVW $-1, R3 MOVW R3, 40(FP) // r1 MOVW R2, 44(FP) // r2 - MOVW R0, 48(FP) // err + MOVW R0, 48(FP) // errno BL runtime·exitsyscall(SB) RET TEXT ·RawSyscall(SB),NOSPLIT,$0-28 - MOVW 0(FP), R7 // sigcall num + MOVW 0(FP), R7 // syscall number MOVW 4(FP), R0 // a1 MOVW 8(FP), R1 // a2 MOVW 12(FP), R2 // a3 @@ -94,33 +96,34 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-28 BCS errorr MOVW R0, 16(FP) // r1 MOVW R1, 20(FP) // r2 - MOVW R2, 24(FP) // err + MOVW R2, 24(FP) // errno RET errorr: MOVW $-1, R3 MOVW R3, 16(FP) // r1 MOVW R2, 20(FP) // r2 - MOVW R0, 24(FP) // err + MOVW R0, 24(FP) // errno RET TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 - MOVW 0(FP), R7 // sigcall num + MOVW 0(FP), R7 // syscall number MOVW 4(FP), R0 // a1 MOVW 8(FP), R1 // a2 MOVW 12(FP), R2 // a3 MOVW 16(FP), R3 // a4 - ADD $24, R13 // a5 to a6 are passed on stack + MOVW R13, R4 + MOVW $20(FP), R13 // a5 to a6 are passed on stack SWI $0 // syscall - SUB $24, R13 + MOVW R4, R13 MOVW $0, R2 BCS errorr6 MOVW R0, 28(FP) // r1 MOVW R1, 32(FP) // r2 - MOVW R2, 36(FP) // err + MOVW R2, 36(FP) // errno RET errorr6: MOVW $-1, R3 MOVW R3, 28(FP) // r1 MOVW R2, 32(FP) // r2 - MOVW R0, 36(FP) // err + MOVW R0, 36(FP) // errno RET diff --git a/src/pkg/syscall/asm_linux_386.s b/src/pkg/syscall/asm_linux_386.s index cf2ab02ab..30b22073d 100644 --- a/src/pkg/syscall/asm_linux_386.s +++ b/src/pkg/syscall/asm_linux_386.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -11,7 +14,7 @@ // func Syscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr); // Trap # in AX, args in BX CX DX SI DI, return in AX -TEXT ·Syscall(SB),NOSPLIT,$0-32 +TEXT ·Syscall(SB),NOSPLIT,$0-28 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry MOVL 8(SP), BX @@ -36,7 +39,7 @@ ok: RET // func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr); -TEXT ·Syscall6(SB),NOSPLIT,$0-44 +TEXT ·Syscall6(SB),NOSPLIT,$0-40 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry MOVL 8(SP), BX @@ -62,7 +65,7 @@ ok6: RET // func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr); -TEXT ·RawSyscall(SB),NOSPLIT,$0-32 +TEXT ·RawSyscall(SB),NOSPLIT,$0-28 MOVL 4(SP), AX // syscall entry MOVL 8(SP), BX MOVL 12(SP), CX @@ -84,7 +87,7 @@ ok1: RET // func RawSyscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr); -TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 MOVL 4(SP), AX // syscall entry MOVL 8(SP), BX MOVL 12(SP), CX @@ -110,7 +113,7 @@ ok2: // func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int) // Kernel interface gets call sub-number and pointer to a0. -TEXT ·socketcall(SB),NOSPLIT,$0-40 +TEXT ·socketcall(SB),NOSPLIT,$0-36 CALL runtime·entersyscall(SB) MOVL $SYS_SOCKETCALL, AX // syscall entry MOVL 4(SP), BX // socket call number @@ -134,7 +137,7 @@ oksock: // func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int) // Kernel interface gets call sub-number and pointer to a0. -TEXT ·rawsocketcall(SB),NOSPLIT,$0-40 +TEXT ·rawsocketcall(SB),NOSPLIT,$0-36 MOVL $SYS_SOCKETCALL, AX // syscall entry MOVL 4(SP), BX // socket call number LEAL 8(SP), CX // pointer to call arguments @@ -159,7 +162,7 @@ oksock1: // taking the address of the return value newoffset. // Underlying system call is // llseek(int fd, int offhi, int offlo, int64 *result, int whence) -TEXT ·Seek(SB),NOSPLIT,$0-32 +TEXT ·seek(SB),NOSPLIT,$0-28 CALL runtime·entersyscall(SB) MOVL $SYS__LLSEEK, AX // syscall entry MOVL 4(SP), BX // fd diff --git a/src/pkg/syscall/asm_linux_amd64.s b/src/pkg/syscall/asm_linux_amd64.s index 28a2a5809..995b60ecd 100644 --- a/src/pkg/syscall/asm_linux_amd64.s +++ b/src/pkg/syscall/asm_linux_amd64.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -13,7 +16,7 @@ // Note that this differs from "standard" ABI convention, which // would pass 4th arg in CX, not R10. -TEXT ·Syscall(SB),NOSPLIT,$0-64 +TEXT ·Syscall(SB),NOSPLIT,$0-56 CALL runtime·entersyscall(SB) MOVQ 16(SP), DI MOVQ 24(SP), SI @@ -38,7 +41,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-88 +TEXT ·Syscall6(SB),NOSPLIT,$0-80 CALL runtime·entersyscall(SB) MOVQ 16(SP), DI MOVQ 24(SP), SI @@ -63,7 +66,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-64 +TEXT ·RawSyscall(SB),NOSPLIT,$0-56 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX @@ -85,7 +88,7 @@ ok1: MOVQ $0, 56(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX @@ -107,7 +110,7 @@ ok2: MOVQ $0, 80(SP) // errno RET -TEXT ·Gettimeofday(SB),NOSPLIT,$0-24 +TEXT ·gettimeofday(SB),NOSPLIT,$0-16 MOVQ 8(SP), DI MOVQ $0, SI MOVQ runtime·__vdso_gettimeofday_sym(SB), AX @@ -121,11 +124,3 @@ TEXT ·Gettimeofday(SB),NOSPLIT,$0-24 ok7: MOVQ $0, 16(SP) // errno RET - -TEXT ·Time(SB),NOSPLIT,$0-32 - MOVQ 8(SP), DI - MOVQ runtime·__vdso_time_sym(SB), AX - CALL AX - MOVQ AX, 16(SP) // tt - MOVQ $0, 24(SP) // errno - RET diff --git a/src/pkg/syscall/asm_linux_arm.s b/src/pkg/syscall/asm_linux_arm.s index bf54b4fe6..a28bc6cfc 100644 --- a/src/pkg/syscall/asm_linux_arm.s +++ b/src/pkg/syscall/asm_linux_arm.s @@ -98,12 +98,12 @@ ok2: RET #define SYS__LLSEEK 140 /* from zsysnum_linux_arm.go */ -// func Seek(fd int, offset int64, whence int) (newoffset int64, errno int) +// func seek(fd int, offset int64, whence int) (newoffset int64, errno int) // Implemented in assembly to avoid allocation when // taking the address of the return value newoffset. // Underlying system call is // llseek(int fd, int offhi, int offlo, int64 *result, int whence) -TEXT ·Seek(SB),NOSPLIT,$0-32 +TEXT ·seek(SB),NOSPLIT,$0-32 BL runtime·entersyscall(SB) MOVW $SYS__LLSEEK, R7 // syscall entry MOVW 4(SP), R0 // fd diff --git a/src/pkg/syscall/asm_nacl_386.s b/src/pkg/syscall/asm_nacl_386.s new file mode 100644 index 000000000..de7c3cc5d --- /dev/null +++ b/src/pkg/syscall/asm_nacl_386.s @@ -0,0 +1,43 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "../../cmd/ld/textflag.h" +#include "../runtime/syscall_nacl.h" + +// +// System call support for 386, Native Client +// + +#define NACL_SYSCALL(code) \ + MOVL $(0x10000 + ((code)<<5)), AX; CALL AX + +#define NACL_SYSJMP(code) \ + MOVL $(0x10000 + ((code)<<5)), AX; JMP AX + +TEXT syscall·Syscall(SB),NOSPLIT,$12-28 + CALL runtime·entersyscall(SB) + MOVL trap+0(FP), AX + MOVL a1+4(FP), BX + MOVL BX, 0(SP) + MOVL a2+8(FP), BX + MOVL BX, 4(SP) + MOVL a3+12(FP), BX + MOVL BX, 8(SP) + SHLL $5, AX + ADDL $0x10000, AX + CALL AX + CMPL AX, $0 + JGE ok + MOVL $-1, r1+16(FP) + MOVL $-1, r2+20(FP) + NEGL AX + MOVL AX, err+24(FP) + CALL runtime·exitsyscall(SB) + RET +ok: + MOVL AX, r1+16(FP) + MOVL DX, r2+20(FP) + MOVL $0, err+24(FP) + CALL runtime·exitsyscall(SB) + RET diff --git a/src/pkg/syscall/asm_nacl_amd64p32.s b/src/pkg/syscall/asm_nacl_amd64p32.s new file mode 100644 index 000000000..de030ec80 --- /dev/null +++ b/src/pkg/syscall/asm_nacl_amd64p32.s @@ -0,0 +1,41 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "../../cmd/ld/textflag.h" +#include "../runtime/syscall_nacl.h" + +// +// System call support for amd64, Native Client +// + +#define NACL_SYSCALL(code) \ + MOVL $(0x10000 + ((code)<<5)), AX; CALL AX + +#define NACL_SYSJMP(code) \ + MOVL $(0x10000 + ((code)<<5)), AX; JMP AX + +TEXT syscall·Syscall(SB),NOSPLIT,$0-28 + CALL runtime·entersyscall(SB) + MOVL trap+0(FP), AX + MOVL a1+4(FP), DI + MOVL a2+8(FP), SI + MOVL a3+12(FP), DX + // more args would use CX, R8, R9 + SHLL $5, AX + ADDL $0x10000, AX + CALL AX + CMPL AX, $0 + JGE ok + MOVL $-1, r1+16(FP) + MOVL $-1, r2+20(FP) + NEGL AX + MOVL AX, err+24(FP) + CALL runtime·exitsyscall(SB) + RET +ok: + MOVL AX, r1+16(FP) + MOVL DX, r2+20(FP) + MOVL $0, err+24(FP) + CALL runtime·exitsyscall(SB) + RET diff --git a/src/pkg/syscall/asm_netbsd_386.s b/src/pkg/syscall/asm_netbsd_386.s index 8caade255..40b30b405 100644 --- a/src/pkg/syscall/asm_netbsd_386.s +++ b/src/pkg/syscall/asm_netbsd_386.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -12,7 +15,7 @@ // func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32); // Trap # in AX, args on stack above caller pc. -TEXT ·Syscall(SB),NOSPLIT,$0-32 +TEXT ·Syscall(SB),NOSPLIT,$0-28 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-44 +TEXT ·Syscall6(SB),NOSPLIT,$0-40 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -63,7 +66,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-56 +TEXT ·Syscall9(SB),NOSPLIT,$0-52 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -93,7 +96,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-32 +TEXT ·RawSyscall(SB),NOSPLIT,$0-28 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI @@ -114,7 +117,7 @@ ok1: MOVL $0, 28(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI diff --git a/src/pkg/syscall/asm_netbsd_amd64.s b/src/pkg/syscall/asm_netbsd_amd64.s index e0b8b3cb8..94ad0284a 100644 --- a/src/pkg/syscall/asm_netbsd_amd64.s +++ b/src/pkg/syscall/asm_netbsd_amd64.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -13,7 +16,7 @@ // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64); // Trap # in AX, args in DI SI DX, return in AX DX -TEXT ·Syscall(SB),NOSPLIT,$0-64 +TEXT ·Syscall(SB),NOSPLIT,$0-56 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX // syscall entry MOVQ 16(SP), DI @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-88 +TEXT ·Syscall6(SB),NOSPLIT,$0-80 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX // syscall entry MOVQ 16(SP), DI @@ -59,7 +62,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-112 +TEXT ·Syscall9(SB),NOSPLIT,$0-104 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX // syscall entry MOVQ 16(SP), DI @@ -91,7 +94,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-64 +TEXT ·RawSyscall(SB),NOSPLIT,$0-56 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX @@ -111,7 +114,7 @@ ok1: MOVQ $0, 56(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX diff --git a/src/pkg/syscall/asm_openbsd_386.s b/src/pkg/syscall/asm_openbsd_386.s index a38349661..7dd2e373f 100644 --- a/src/pkg/syscall/asm_openbsd_386.s +++ b/src/pkg/syscall/asm_openbsd_386.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -12,7 +15,7 @@ // func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32); // Trap # in AX, args on stack above caller pc. -TEXT ·Syscall(SB),NOSPLIT,$0-32 +TEXT ·Syscall(SB),NOSPLIT,$0-28 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-44 +TEXT ·Syscall6(SB),NOSPLIT,$0-40 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -63,7 +66,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-56 +TEXT ·Syscall9(SB),NOSPLIT,$0-52 CALL runtime·entersyscall(SB) MOVL 4(SP), AX // syscall entry // slide args down on top of system call number @@ -93,7 +96,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-32 +TEXT ·RawSyscall(SB),NOSPLIT,$0-28 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI @@ -114,7 +117,7 @@ ok1: MOVL $0, 28(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI diff --git a/src/pkg/syscall/asm_openbsd_amd64.s b/src/pkg/syscall/asm_openbsd_amd64.s index 1bf25f1db..e127bf220 100644 --- a/src/pkg/syscall/asm_openbsd_amd64.s +++ b/src/pkg/syscall/asm_openbsd_amd64.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -13,7 +16,7 @@ // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64); // Trap # in AX, args in DI SI DX, return in AX DX -TEXT ·Syscall(SB),NOSPLIT,$0-64 +TEXT ·Syscall(SB),NOSPLIT,$0-56 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX // syscall entry MOVQ 16(SP), DI @@ -36,7 +39,7 @@ ok: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall6(SB),NOSPLIT,$0-88 +TEXT ·Syscall6(SB),NOSPLIT,$0-80 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX // syscall entry MOVQ 16(SP), DI @@ -59,7 +62,7 @@ ok6: CALL runtime·exitsyscall(SB) RET -TEXT ·Syscall9(SB),NOSPLIT,$0-112 +TEXT ·Syscall9(SB),NOSPLIT,$0-104 CALL runtime·entersyscall(SB) MOVQ 8(SP), AX // syscall entry MOVQ 16(SP), DI @@ -91,7 +94,7 @@ ok9: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-64 +TEXT ·RawSyscall(SB),NOSPLIT,$0-56 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX @@ -111,7 +114,7 @@ ok1: MOVQ $0, 56(SP) // errno RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 MOVQ 16(SP), DI MOVQ 24(SP), SI MOVQ 32(SP), DX diff --git a/src/pkg/syscall/asm_plan9_386.s b/src/pkg/syscall/asm_plan9_386.s index 7ebd20690..f8c07c407 100644 --- a/src/pkg/syscall/asm_plan9_386.s +++ b/src/pkg/syscall/asm_plan9_386.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -87,7 +90,7 @@ copyresult4: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-32 +TEXT ·RawSyscall(SB),NOSPLIT,$0-28 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI @@ -102,7 +105,7 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-32 MOVL AX, err+28(SP) RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 MOVL 4(SP), AX // syscall entry // slide args down on top of system call number LEAL 8(SP), SI @@ -123,7 +126,7 @@ TEXT ·RawSyscall6(SB),NOSPLIT,$0-44 #define SYS_SEEK 39 /* from zsysnum_plan9_386.go */ //func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string) -TEXT ·seek(SB),NOSPLIT,$0-40 +TEXT ·seek(SB),NOSPLIT,$0-36 LEAL newoffset+24(SP), AX MOVL AX, placeholder+4(SP) diff --git a/src/pkg/syscall/asm_plan9_amd64.s b/src/pkg/syscall/asm_plan9_amd64.s index 880bf7c6f..2154a87d5 100644 --- a/src/pkg/syscall/asm_plan9_amd64.s +++ b/src/pkg/syscall/asm_plan9_amd64.s @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + #include "../../cmd/ld/textflag.h" // @@ -91,7 +94,7 @@ copyresult4: CALL runtime·exitsyscall(SB) RET -TEXT ·RawSyscall(SB),NOSPLIT,$0-64 +TEXT ·RawSyscall(SB),NOSPLIT,$0-56 MOVQ $0x8000, AX // for NxM MOVQ 8(SP), BP // syscall entry // slide args down on top of system call number @@ -107,7 +110,7 @@ TEXT ·RawSyscall(SB),NOSPLIT,$0-64 MOVQ AX, err+56(SP) RET -TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 +TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 MOVQ $0x8000, AX // for NxM MOVQ 8(SP), BP // syscall entry // slide args down on top of system call number @@ -129,7 +132,7 @@ TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 #define SYS_SEEK 39 /* from zsysnum_plan9_amd64.go */ //func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string) -TEXT ·seek(SB),NOSPLIT,$0-64 +TEXT ·seek(SB),NOSPLIT,$0-56 LEAQ newoffset+40(SP), AX MOVQ AX, placeholder+8(SP) @@ -160,7 +163,7 @@ copyresult6: //func exit(code int) // Import runtime·exit for cleanly exiting. -TEXT ·exit(SB),NOSPLIT,$8-4 +TEXT ·exit(SB),NOSPLIT,$8-8 MOVQ code+0(FP), AX MOVQ AX, 0(SP) CALL runtime·exit(SB) diff --git a/src/pkg/syscall/asm_solaris_amd64.s b/src/pkg/syscall/asm_solaris_amd64.s new file mode 100644 index 000000000..3735890fa --- /dev/null +++ b/src/pkg/syscall/asm_solaris_amd64.s @@ -0,0 +1,7 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +// System calls for amd64, Solaris are implemented in ../runtime/syscall_solaris.goc +// diff --git a/src/pkg/syscall/consistency_unix_test.go b/src/pkg/syscall/consistency_unix_test.go deleted file mode 100644 index 73630bc61..000000000 --- a/src/pkg/syscall/consistency_unix_test.go +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build freebsd dragonfly darwin linux netbsd openbsd - -// This file tests that some basic syscalls are consistent across -// all Unixes. - -package syscall_test - -import "syscall" - -// {Set,Get}priority and needed constants for them -func _() { - var ( - _ func(int, int, int) error = syscall.Setpriority - _ func(int, int) (int, error) = syscall.Getpriority - ) - const ( - _ int = syscall.PRIO_USER - _ int = syscall.PRIO_PROCESS - _ int = syscall.PRIO_PGRP - ) -} - -// termios functions and constants -func _() { - const ( - _ int = syscall.TCIFLUSH - _ int = syscall.TCIOFLUSH - _ int = syscall.TCOFLUSH - ) -} diff --git a/src/pkg/syscall/dir_plan9.go b/src/pkg/syscall/dir_plan9.go index b7ab4cd10..697bf5499 100644 --- a/src/pkg/syscall/dir_plan9.go +++ b/src/pkg/syscall/dir_plan9.go @@ -11,6 +11,7 @@ import "errors" var ( ErrShortStat = errors.New("stat buffer too short") ErrBadStat = errors.New("malformed stat buffer") + ErrBadName = errors.New("bad character in file name") ) // A Qid represents a 9P server's unique identification for a file. @@ -53,7 +54,7 @@ var nullDir = Dir{ } // Null assigns special "don't touch" values to members of d to -// avoid modifiying them during syscall.Wstat. +// avoid modifying them during syscall.Wstat. func (d *Dir) Null() { *d = nullDir } // Marshal encodes a 9P stat message corresponding to d into b @@ -65,6 +66,12 @@ func (d *Dir) Marshal(b []byte) (n int, err error) { return n, ErrShortStat } + for _, c := range d.Name { + if c == '/' { + return n, ErrBadName + } + } + b = pbit16(b, uint16(n)-2) b = pbit16(b, d.Type) b = pbit32(b, d.Dev) diff --git a/src/pkg/syscall/env_unix.go b/src/pkg/syscall/env_unix.go index 5970df8fc..ad354ed05 100644 --- a/src/pkg/syscall/env_unix.go +++ b/src/pkg/syscall/env_unix.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build darwin dragonfly freebsd linux netbsd openbsd +// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris // Unix environment variables. diff --git a/src/pkg/syscall/exec_linux.go b/src/pkg/syscall/exec_linux.go index a1656e8dc..f27950f73 100644 --- a/src/pkg/syscall/exec_linux.go +++ b/src/pkg/syscall/exec_linux.go @@ -131,11 +131,11 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr // User and groups if cred := sys.Credential; cred != nil { ngroups := uintptr(len(cred.Groups)) - groups := uintptr(0) + var groups unsafe.Pointer if ngroups > 0 { - groups = uintptr(unsafe.Pointer(&cred.Groups[0])) + groups = unsafe.Pointer(&cred.Groups[0]) } - _, _, err1 = RawSyscall(SYS_SETGROUPS, ngroups, groups, 0) + _, _, err1 = RawSyscall(SYS_SETGROUPS, ngroups, uintptr(groups), 0) if err1 != 0 { goto childerror } diff --git a/src/pkg/syscall/exec_plan9.go b/src/pkg/syscall/exec_plan9.go index 99ad2f158..45ee542bb 100644 --- a/src/pkg/syscall/exec_plan9.go +++ b/src/pkg/syscall/exec_plan9.go @@ -486,7 +486,7 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) if err != nil || n != 0 { if n != 0 { - err = NewError(string(errbuf[:])) + err = NewError(string(errbuf[:n])) } // Child failed; wait for it to exit, to make sure diff --git a/src/pkg/syscall/exec_solaris.go b/src/pkg/syscall/exec_solaris.go new file mode 100644 index 000000000..97de6ca00 --- /dev/null +++ b/src/pkg/syscall/exec_solaris.go @@ -0,0 +1,243 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +import ( + "unsafe" +) + +type SysProcAttr struct { + Chroot string // Chroot. + Credential *Credential // Credential. + Setsid bool // Create session. + Setpgid bool // Set process group ID to new pid (SYSV setpgrp) + Setctty bool // Set controlling terminal to fd 0 + Noctty bool // Detach fd 0 from controlling terminal +} + +// Implemented in runtime package. +func runtime_BeforeFork() +func runtime_AfterFork() + +func chdir(path uintptr) (err Errno) +func chroot1(path uintptr) (err Errno) +func close(fd uintptr) (err Errno) +func execve(path uintptr, argv uintptr, envp uintptr) (err Errno) +func exit(code uintptr) +func fcntl1(fd uintptr, cmd uintptr, arg uintptr) (val uintptr, err Errno) +func forkx(flags uintptr) (pid uintptr, err Errno) +func ioctl(fd uintptr, req uintptr, arg uintptr) (err Errno) +func setgid(gid uintptr) (err Errno) +func setgroups1(ngid uintptr, gid uintptr) (err Errno) +func setsid() (pid uintptr, err Errno) +func setuid(uid uintptr) (err Errno) +func setpgid(pid uintptr, pgid uintptr) (err Errno) +func write1(fd uintptr, buf uintptr, nbyte uintptr) (n uintptr, err Errno) + +// Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child. +// If a dup or exec fails, write the errno error to pipe. +// (Pipe is close-on-exec so if exec succeeds, it will be closed.) +// In the child, this function must not acquire any locks, because +// they might have been locked at the time of the fork. This means +// no rescheduling, no malloc calls, and no new stack segments. +// +// We call hand-crafted syscalls, implemented in +// ../runtime/syscall_solaris.goc, rather than generated libc wrappers +// because we need to avoid lazy-loading the functions (might malloc, +// split the stack, or acquire mutexes). We can't call RawSyscall +// because it's not safe even for BSD-subsystem calls. +func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr *ProcAttr, sys *SysProcAttr, pipe int) (pid int, err Errno) { + // Declare all variables at top in case any + // declarations require heap allocation (e.g., err1). + var ( + r1 uintptr + err1 Errno + nextfd int + i int + ) + + // guard against side effects of shuffling fds below. + // Make sure that nextfd is beyond any currently open files so + // that we can't run the risk of overwriting any of them. + fd := make([]int, len(attr.Files)) + nextfd = len(attr.Files) + for i, ufd := range attr.Files { + if nextfd < int(ufd) { + nextfd = int(ufd) + } + fd[i] = int(ufd) + } + nextfd++ + + // About to call fork. + // No more allocation or calls of non-assembly functions. + runtime_BeforeFork() + r1, err1 = forkx(0x1) // FORK_NOSIGCHLD + if err1 != 0 { + runtime_AfterFork() + return 0, err1 + } + + if r1 != 0 { + // parent; return PID + runtime_AfterFork() + return int(r1), 0 + } + + // Fork succeeded, now in child. + + // Session ID + if sys.Setsid { + _, err1 = setsid() + if err1 != 0 { + goto childerror + } + } + + // Set process group + if sys.Setpgid { + err1 = setpgid(0, 0) + if err1 != 0 { + goto childerror + } + } + + // Chroot + if chroot != nil { + err1 = chroot1(uintptr(unsafe.Pointer(chroot))) + if err1 != 0 { + goto childerror + } + } + + // User and groups + if cred := sys.Credential; cred != nil { + ngroups := uintptr(len(cred.Groups)) + groups := uintptr(0) + if ngroups > 0 { + groups = uintptr(unsafe.Pointer(&cred.Groups[0])) + } + err1 = setgroups1(ngroups, groups) + if err1 != 0 { + goto childerror + } + err1 = setgid(uintptr(cred.Gid)) + if err1 != 0 { + goto childerror + } + err1 = setuid(uintptr(cred.Uid)) + if err1 != 0 { + goto childerror + } + } + + // Chdir + if dir != nil { + err1 = chdir(uintptr(unsafe.Pointer(dir))) + if err1 != 0 { + goto childerror + } + } + + // Pass 1: look for fd[i] < i and move those up above len(fd) + // so that pass 2 won't stomp on an fd it needs later. + if pipe < nextfd { + _, err1 = fcntl1(uintptr(pipe), F_DUP2FD, uintptr(nextfd)) + if err1 != 0 { + goto childerror + } + fcntl1(uintptr(nextfd), F_SETFD, FD_CLOEXEC) + pipe = nextfd + nextfd++ + } + for i = 0; i < len(fd); i++ { + if fd[i] >= 0 && fd[i] < int(i) { + _, err1 = fcntl1(uintptr(fd[i]), F_DUP2FD, uintptr(nextfd)) + if err1 != 0 { + goto childerror + } + fcntl1(uintptr(nextfd), F_SETFD, FD_CLOEXEC) + fd[i] = nextfd + nextfd++ + if nextfd == pipe { // don't stomp on pipe + nextfd++ + } + } + } + + // Pass 2: dup fd[i] down onto i. + for i = 0; i < len(fd); i++ { + if fd[i] == -1 { + close(uintptr(i)) + continue + } + if fd[i] == int(i) { + // dup2(i, i) won't clear close-on-exec flag on Linux, + // probably not elsewhere either. + _, err1 = fcntl1(uintptr(fd[i]), F_SETFD, 0) + if err1 != 0 { + goto childerror + } + continue + } + // The new fd is created NOT close-on-exec, + // which is exactly what we want. + _, err1 = fcntl1(uintptr(fd[i]), F_DUP2FD, uintptr(i)) + if err1 != 0 { + goto childerror + } + } + + // By convention, we don't close-on-exec the fds we are + // started with, so if len(fd) < 3, close 0, 1, 2 as needed. + // Programs that know they inherit fds >= 3 will need + // to set them close-on-exec. + for i = len(fd); i < 3; i++ { + close(uintptr(i)) + } + + // Detach fd 0 from tty + if sys.Noctty { + err1 = ioctl(0, uintptr(TIOCNOTTY), 0) + if err1 != 0 { + goto childerror + } + } + + // Make fd 0 the tty + if sys.Setctty { + err1 = ioctl(0, uintptr(TIOCSCTTY), 0) + if err1 != 0 { + goto childerror + } + } + + // Time to exec. + err1 = execve( + uintptr(unsafe.Pointer(argv0)), + uintptr(unsafe.Pointer(&argv[0])), + uintptr(unsafe.Pointer(&envv[0]))) + +childerror: + // send error code on pipe + write1(uintptr(pipe), uintptr(unsafe.Pointer(&err1)), unsafe.Sizeof(err1)) + for { + exit(253) + } +} + +// Try to open a pipe with O_CLOEXEC set on both file descriptors. +func forkExecPipe(p []int) error { + err := Pipe(p) + if err != nil { + return err + } + _, err = fcntl(p[0], F_SETFD, FD_CLOEXEC) + if err != nil { + return err + } + _, err = fcntl(p[1], F_SETFD, FD_CLOEXEC) + return err +} diff --git a/src/pkg/syscall/exec_unix.go b/src/pkg/syscall/exec_unix.go index b82e39701..890bfdc22 100644 --- a/src/pkg/syscall/exec_unix.go +++ b/src/pkg/syscall/exec_unix.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build darwin dragonfly freebsd linux netbsd openbsd +// +build darwin dragonfly freebsd linux netbsd openbsd solaris // Fork, exec, wait, etc. @@ -158,7 +158,7 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) return 0, err } - if runtime.GOOS == "freebsd" && len(argv[0]) > len(argv0) { + if (runtime.GOOS == "freebsd" || runtime.GOOS == "dragonfly") && len(argv[0]) > len(argv0) { argvp[0] = argv0p } diff --git a/src/pkg/syscall/fd_nacl.go b/src/pkg/syscall/fd_nacl.go new file mode 100644 index 000000000..74324142a --- /dev/null +++ b/src/pkg/syscall/fd_nacl.go @@ -0,0 +1,326 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// File descriptor support for Native Client. +// We want to provide access to a broader range of (simulated) files than +// Native Client allows, so we maintain our own file descriptor table exposed +// to higher-level packages. + +package syscall + +import ( + "sync" +) + +// files is the table indexed by a file descriptor. +var files struct { + sync.RWMutex + tab []*file +} + +// A file is an open file, something with a file descriptor. +// A particular *file may appear in files multiple times, due to use of Dup or Dup2. +type file struct { + fdref int // uses in files.tab + impl fileImpl // underlying implementation +} + +// A fileImpl is the implementation of something that can be a file. +type fileImpl interface { + // Standard operations. + // These can be called concurrently from multiple goroutines. + stat(*Stat_t) error + read([]byte) (int, error) + write([]byte) (int, error) + seek(int64, int) (int64, error) + pread([]byte, int64) (int, error) + pwrite([]byte, int64) (int, error) + + // Close is called when the last reference to a *file is removed + // from the file descriptor table. It may be called concurrently + // with active operations such as blocked read or write calls. + close() error +} + +// newFD adds impl to the file descriptor table, +// returning the new file descriptor. +// Like Unix, it uses the lowest available descriptor. +func newFD(impl fileImpl) int { + files.Lock() + defer files.Unlock() + f := &file{impl: impl, fdref: 1} + for fd, oldf := range files.tab { + if oldf == nil { + files.tab[fd] = f + return fd + } + } + fd := len(files.tab) + files.tab = append(files.tab, f) + return fd +} + +// Install Native Client stdin, stdout, stderr. +func init() { + newFD(&naclFile{naclFD: 0}) + newFD(&naclFile{naclFD: 1}) + newFD(&naclFile{naclFD: 2}) +} + +// fdToFile retrieves the *file corresponding to a file descriptor. +func fdToFile(fd int) (*file, error) { + files.Lock() + defer files.Unlock() + if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil { + return nil, EBADF + } + return files.tab[fd], nil +} + +func Close(fd int) error { + files.Lock() + if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil { + files.Unlock() + return EBADF + } + f := files.tab[fd] + files.tab[fd] = nil + f.fdref-- + fdref := f.fdref + files.Unlock() + if fdref > 0 { + return nil + } + return f.impl.close() +} + +func CloseOnExec(fd int) { + // nothing to do - no exec +} + +func Dup(fd int) (int, error) { + files.Lock() + defer files.Unlock() + if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil { + return -1, EBADF + } + f := files.tab[fd] + f.fdref++ + for newfd, oldf := range files.tab { + if oldf == nil { + files.tab[newfd] = f + return newfd, nil + } + } + newfd := len(files.tab) + files.tab = append(files.tab, f) + return newfd, nil +} + +func Dup2(fd, newfd int) error { + files.Lock() + defer files.Unlock() + if fd < 0 || fd >= len(files.tab) || files.tab[fd] == nil || newfd < 0 || newfd >= len(files.tab)+100 { + files.Unlock() + return EBADF + } + f := files.tab[fd] + f.fdref++ + for cap(files.tab) <= newfd { + files.tab = append(files.tab[:cap(files.tab)], nil) + } + oldf := files.tab[newfd] + var oldfdref int + if oldf != nil { + oldf.fdref-- + oldfdref = oldf.fdref + } + files.tab[newfd] = f + files.Unlock() + if oldf != nil { + if oldfdref == 0 { + oldf.impl.close() + } + } + return nil +} + +func Fstat(fd int, st *Stat_t) error { + f, err := fdToFile(fd) + if err != nil { + return err + } + return f.impl.stat(st) +} + +func Read(fd int, b []byte) (int, error) { + f, err := fdToFile(fd) + if err != nil { + return 0, err + } + return f.impl.read(b) +} + +var zerobuf [0]byte + +func Write(fd int, b []byte) (int, error) { + if b == nil { + // avoid nil in syscalls; nacl doesn't like that. + b = zerobuf[:] + } + f, err := fdToFile(fd) + if err != nil { + return 0, err + } + return f.impl.write(b) +} + +func Pread(fd int, b []byte, offset int64) (int, error) { + f, err := fdToFile(fd) + if err != nil { + return 0, err + } + return f.impl.pread(b, offset) +} + +func Pwrite(fd int, b []byte, offset int64) (int, error) { + f, err := fdToFile(fd) + if err != nil { + return 0, err + } + return f.impl.pwrite(b, offset) +} + +func Seek(fd int, offset int64, whence int) (int64, error) { + f, err := fdToFile(fd) + if err != nil { + return 0, err + } + return f.impl.seek(offset, whence) +} + +// defaulFileImpl implements fileImpl. +// It can be embedded to complete a partial fileImpl implementation. +type defaultFileImpl struct{} + +func (*defaultFileImpl) close() error { return nil } +func (*defaultFileImpl) stat(*Stat_t) error { return ENOSYS } +func (*defaultFileImpl) read([]byte) (int, error) { return 0, ENOSYS } +func (*defaultFileImpl) write([]byte) (int, error) { return 0, ENOSYS } +func (*defaultFileImpl) seek(int64, int) (int64, error) { return 0, ENOSYS } +func (*defaultFileImpl) pread([]byte, int64) (int, error) { return 0, ENOSYS } +func (*defaultFileImpl) pwrite([]byte, int64) (int, error) { return 0, ENOSYS } + +// naclFile is the fileImpl implementation for a Native Client file descriptor. +type naclFile struct { + defaultFileImpl + naclFD int +} + +func (f *naclFile) stat(st *Stat_t) error { + return naclFstat(f.naclFD, st) +} + +func (f *naclFile) read(b []byte) (int, error) { + n, err := naclRead(f.naclFD, b) + if err != nil { + n = 0 + } + return n, err +} + +// implemented in package runtime, to add time header on playground +func naclWrite(fd int, b []byte) int + +func (f *naclFile) write(b []byte) (int, error) { + n := naclWrite(f.naclFD, b) + if n < 0 { + return 0, Errno(-n) + } + return n, nil +} + +func (f *naclFile) seek(off int64, whence int) (int64, error) { + old := off + err := naclSeek(f.naclFD, &off, whence) + if err != nil { + return old, err + } + return off, nil +} + +func (f *naclFile) prw(b []byte, offset int64, rw func([]byte) (int, error)) (int, error) { + // NaCl has no pread; simulate with seek and hope for no races. + old, err := f.seek(0, 1) + if err != nil { + return 0, err + } + if _, err := f.seek(offset, 0); err != nil { + return 0, err + } + n, err := rw(b) + f.seek(old, 0) + return n, err +} + +func (f *naclFile) pread(b []byte, offset int64) (int, error) { + return f.prw(b, offset, f.read) +} + +func (f *naclFile) pwrite(b []byte, offset int64) (int, error) { + return f.prw(b, offset, f.write) +} + +func (f *naclFile) close() error { + err := naclClose(f.naclFD) + f.naclFD = -1 + return err +} + +// A pipeFile is an in-memory implementation of a pipe. +// The byteq implementation is in net_nacl.go. +type pipeFile struct { + defaultFileImpl + rd *byteq + wr *byteq +} + +func (f *pipeFile) close() error { + if f.rd != nil { + f.rd.close() + } + if f.wr != nil { + f.wr.close() + } + return nil +} + +func (f *pipeFile) read(b []byte) (int, error) { + if f.rd == nil { + return 0, EINVAL + } + n, err := f.rd.read(b, 0) + if err == EAGAIN { + err = nil + } + return n, err +} + +func (f *pipeFile) write(b []byte) (int, error) { + if f.wr == nil { + return 0, EINVAL + } + n, err := f.wr.write(b, 0) + if err == EAGAIN { + err = EPIPE + } + return n, err +} + +func Pipe(fd []int) error { + q := newByteq() + fd[0] = newFD(&pipeFile{rd: q}) + fd[1] = newFD(&pipeFile{wr: q}) + return nil +} diff --git a/src/pkg/syscall/flock.go b/src/pkg/syscall/flock.go new file mode 100644 index 000000000..62736ae9d --- /dev/null +++ b/src/pkg/syscall/flock.go @@ -0,0 +1,22 @@ +// +build linux darwin freebsd openbsd netbsd dragonfly + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +import "unsafe" + +// fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux +// systems by flock_linux_32bit.go to be SYS_FCNTL64. +var fcntl64Syscall uintptr = SYS_FCNTL + +// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. +func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { + _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk))) + if errno == 0 { + return nil + } + return errno +} diff --git a/src/pkg/syscall/flock_linux_32bit.go b/src/pkg/syscall/flock_linux_32bit.go new file mode 100644 index 000000000..500a97344 --- /dev/null +++ b/src/pkg/syscall/flock_linux_32bit.go @@ -0,0 +1,13 @@ +// +build linux,386 linux,arm + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +func init() { + // On 32-bit Linux systems, the fcntl syscall that matches Go's + // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. + fcntl64Syscall = SYS_FCNTL64 +} diff --git a/src/pkg/syscall/fs_nacl.go b/src/pkg/syscall/fs_nacl.go new file mode 100644 index 000000000..ac9239483 --- /dev/null +++ b/src/pkg/syscall/fs_nacl.go @@ -0,0 +1,815 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// A simulated Unix-like file system for use within NaCl. +// +// The simulation is not particularly tied to NaCl other than the reuse +// of NaCl's definition for the Stat_t structure. +// +// The file system need never be written to disk, so it is represented as +// in-memory Go data structures, never in a serialized form. +// +// TODO: Perhaps support symlinks, although they muck everything up. + +package syscall + +import ( + "sync" + "unsafe" +) + +// Provided by package runtime. +func now() (sec int64, nsec int32) + +// An fsys is a file system. +// Since there is no I/O (everything is in memory), +// the global lock mu protects the whole file system state, +// and that's okay. +type fsys struct { + mu sync.Mutex + root *inode // root directory + cwd *inode // process current directory + inum uint64 // number of inodes created + dev []func() (devFile, error) // table for opening devices +} + +// A devFile is the implementation required of device files +// like /dev/null or /dev/random. +type devFile interface { + pread([]byte, int64) (int, error) + pwrite([]byte, int64) (int, error) +} + +// An inode is a (possibly special) file in the file system. +type inode struct { + Stat_t + data []byte + dir []dirent +} + +// A dirent describes a single directory entry. +type dirent struct { + name string + inode *inode +} + +// An fsysFile is the fileImpl implementation backed by the file system. +type fsysFile struct { + defaultFileImpl + fsys *fsys + inode *inode + openmode int + offset int64 + dev devFile +} + +// newFsys creates a new file system. +func newFsys() *fsys { + fs := &fsys{} + fs.mu.Lock() + defer fs.mu.Unlock() + ip := fs.newInode() + ip.Mode = 0555 | S_IFDIR + fs.dirlink(ip, ".", ip) + fs.dirlink(ip, "..", ip) + fs.cwd = ip + fs.root = ip + return fs +} + +var fs = newFsys() + +func init() { + Mkdir("/dev", 0555) + Mkdir("/tmp", 0777) + mkdev("/dev/null", 0666, openNull) + mkdev("/dev/random", 0444, openRandom) + mkdev("/dev/urandom", 0444, openRandom) + mkdev("/dev/zero", 0666, openZero) + chdirEnv() +} + +func chdirEnv() { + pwd, ok := Getenv("NACLPWD") + if ok { + Chdir(pwd) + } +} + +// Except where indicated otherwise, unexported methods on fsys +// expect fs.mu to have been locked by the caller. + +// newInode creates a new inode. +func (fs *fsys) newInode() *inode { + fs.inum++ + ip := &inode{ + Stat_t: Stat_t{ + Ino: fs.inum, + Blksize: 512, + }, + } + return ip +} + +// atime sets ip.Atime to the current time. +func (fs *fsys) atime(ip *inode) { + sec, nsec := now() + ip.Atime, ip.AtimeNsec = sec, int64(nsec) +} + +// mtime sets ip.Mtime to the current time. +func (fs *fsys) mtime(ip *inode) { + sec, nsec := now() + ip.Mtime, ip.MtimeNsec = sec, int64(nsec) +} + +// dirlookup looks for an entry in the directory dp with the given name. +// It returns the directory entry and its index within the directory. +func (fs *fsys) dirlookup(dp *inode, name string) (de *dirent, index int, err error) { + fs.atime(dp) + for i := range dp.dir { + de := &dp.dir[i] + if de.name == name { + fs.atime(de.inode) + return de, i, nil + } + } + return nil, 0, ENOENT +} + +// dirlink adds to the directory dp an entry for name pointing at the inode ip. +// If dp already contains an entry for name, that entry is overwritten. +func (fs *fsys) dirlink(dp *inode, name string, ip *inode) { + fs.mtime(dp) + fs.atime(ip) + ip.Nlink++ + for i := range dp.dir { + if dp.dir[i].name == name { + dp.dir[i] = dirent{name, ip} + return + } + } + dp.dir = append(dp.dir, dirent{name, ip}) + dp.dirSize() +} + +func (dp *inode) dirSize() { + dp.Size = int64(len(dp.dir)) * (8 + 8 + 2 + 256) // Dirent +} + +// skipelem splits path into the first element and the remainder. +// the returned first element contains no slashes, and the returned +// remainder does not begin with a slash. +func skipelem(path string) (elem, rest string) { + for len(path) > 0 && path[0] == '/' { + path = path[1:] + } + if len(path) == 0 { + return "", "" + } + i := 0 + for i < len(path) && path[i] != '/' { + i++ + } + elem, path = path[:i], path[i:] + for len(path) > 0 && path[0] == '/' { + path = path[1:] + } + return elem, path +} + +// namei translates a file system path name into an inode. +// If parent is false, the returned ip corresponds to the given name, and elem is the empty string. +// If parent is false, the walk stops at the next-to-last element in the name, +// so that ip is the parent directory and elem is the final element in the path. +func (fs *fsys) namei(path string, parent bool) (ip *inode, elem string, err error) { + // Reject NUL in name. + for i := 0; i < len(path); i++ { + if path[i] == '\x00' { + return nil, "", EINVAL + } + } + + // Reject empty name. + if path == "" { + return nil, "", EINVAL + } + + if path[0] == '/' { + ip = fs.root + } else { + ip = fs.cwd + } + + for len(path) > 0 && path[len(path)-1] == '/' { + path = path[:len(path)-1] + } + + for { + elem, rest := skipelem(path) + if elem == "" { + if parent && ip.Mode&S_IFMT == S_IFDIR { + return ip, ".", nil + } + break + } + if ip.Mode&S_IFMT != S_IFDIR { + return nil, "", ENOTDIR + } + if len(elem) >= 256 { + return nil, "", ENAMETOOLONG + } + if parent && rest == "" { + // Stop one level early. + return ip, elem, nil + } + de, _, err := fs.dirlookup(ip, elem) + if err != nil { + return nil, "", err + } + ip = de.inode + path = rest + } + if parent { + return nil, "", ENOTDIR + } + return ip, "", nil +} + +// open opens or creates a file with the given name, open mode, +// and permission mode bits. +func (fs *fsys) open(name string, openmode int, mode uint32) (fileImpl, error) { + dp, elem, err := fs.namei(name, true) + if err != nil { + return nil, err + } + var ( + ip *inode + dev devFile + ) + de, _, err := fs.dirlookup(dp, elem) + if err != nil { + if openmode&O_CREATE == 0 { + return nil, err + } + ip = fs.newInode() + ip.Mode = mode + fs.dirlink(dp, elem, ip) + if ip.Mode&S_IFMT == S_IFDIR { + fs.dirlink(ip, ".", ip) + fs.dirlink(ip, "..", dp) + } + } else { + ip = de.inode + if openmode&(O_CREATE|O_EXCL) == O_CREATE|O_EXCL { + return nil, EEXIST + } + if openmode&O_TRUNC != 0 { + if ip.Mode&S_IFMT == S_IFDIR { + return nil, EISDIR + } + ip.data = nil + } + if ip.Mode&S_IFMT == S_IFCHR { + if ip.Rdev < 0 || ip.Rdev >= int64(len(fs.dev)) || fs.dev[ip.Rdev] == nil { + return nil, ENODEV + } + dev, err = fs.dev[ip.Rdev]() + if err != nil { + return nil, err + } + } + } + + switch openmode & O_ACCMODE { + case O_WRONLY, O_RDWR: + if ip.Mode&S_IFMT == S_IFDIR { + return nil, EISDIR + } + } + + switch ip.Mode & S_IFMT { + case S_IFDIR: + if openmode&O_ACCMODE != O_RDONLY { + return nil, EISDIR + } + + case S_IFREG: + // ok + + case S_IFCHR: + // handled above + + default: + // TODO: some kind of special file + return nil, EPERM + } + + f := &fsysFile{ + fsys: fs, + inode: ip, + openmode: openmode, + dev: dev, + } + if openmode&O_APPEND != 0 { + f.offset = ip.Size + } + return f, nil +} + +// fsysFile methods to implement fileImpl. + +func (f *fsysFile) stat(st *Stat_t) error { + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + *st = f.inode.Stat_t + return nil +} + +func (f *fsysFile) read(b []byte) (int, error) { + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + n, err := f.preadLocked(b, f.offset) + f.offset += int64(n) + return n, err +} + +func ReadDirent(fd int, buf []byte) (int, error) { + f, err := fdToFsysFile(fd) + if err != nil { + return 0, err + } + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + if f.inode.Mode&S_IFMT != S_IFDIR { + return 0, EINVAL + } + n, err := f.preadLocked(buf, f.offset) + f.offset += int64(n) + return n, err +} + +func (f *fsysFile) write(b []byte) (int, error) { + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + n, err := f.pwriteLocked(b, f.offset) + f.offset += int64(n) + return n, err +} + +func (f *fsysFile) seek(offset int64, whence int) (int64, error) { + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + switch whence { + case 1: + offset += f.offset + case 2: + offset += f.inode.Size + } + if offset < 0 { + return 0, EINVAL + } + if offset > f.inode.Size { + return 0, EINVAL + } + f.offset = offset + return offset, nil +} + +func (f *fsysFile) pread(b []byte, offset int64) (int, error) { + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + return f.preadLocked(b, offset) +} + +func (f *fsysFile) pwrite(b []byte, offset int64) (int, error) { + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + return f.pwriteLocked(b, offset) +} + +func (f *fsysFile) preadLocked(b []byte, offset int64) (int, error) { + if f.openmode&O_ACCMODE == O_WRONLY { + return 0, EINVAL + } + if offset < 0 { + return 0, EINVAL + } + if f.dev != nil { + f.fsys.atime(f.inode) + f.fsys.mu.Unlock() + defer f.fsys.mu.Lock() + return f.dev.pread(b, offset) + } + if offset > f.inode.Size { + return 0, nil + } + if int64(len(b)) > f.inode.Size-offset { + b = b[:f.inode.Size-offset] + } + + if f.inode.Mode&S_IFMT == S_IFDIR { + if offset%direntSize != 0 || len(b) != 0 && len(b) < direntSize { + return 0, EINVAL + } + fs.atime(f.inode) + n := 0 + for len(b) >= direntSize { + src := f.inode.dir[int(offset/direntSize)] + dst := (*Dirent)(unsafe.Pointer(&b[0])) + dst.Ino = int64(src.inode.Ino) + dst.Off = offset + dst.Reclen = direntSize + for i := range dst.Name { + dst.Name[i] = 0 + } + copy(dst.Name[:], src.name) + n += direntSize + offset += direntSize + b = b[direntSize:] + } + return n, nil + } + + fs.atime(f.inode) + n := copy(b, f.inode.data[offset:]) + return n, nil +} + +func (f *fsysFile) pwriteLocked(b []byte, offset int64) (int, error) { + if f.openmode&O_ACCMODE == O_RDONLY { + return 0, EINVAL + } + if offset < 0 { + return 0, EINVAL + } + if f.dev != nil { + f.fsys.atime(f.inode) + f.fsys.mu.Unlock() + defer f.fsys.mu.Lock() + return f.dev.pwrite(b, offset) + } + if offset > f.inode.Size { + return 0, EINVAL + } + f.fsys.mtime(f.inode) + n := copy(f.inode.data[offset:], b) + if n < len(b) { + f.inode.data = append(f.inode.data, b[n:]...) + f.inode.Size = int64(len(f.inode.data)) + } + return len(b), nil +} + +// Standard Unix system calls. + +func Open(path string, openmode int, perm uint32) (fd int, err error) { + fs.mu.Lock() + defer fs.mu.Unlock() + f, err := fs.open(path, openmode, perm&0777|S_IFREG) + if err != nil { + return -1, err + } + return newFD(f), nil +} + +func Mkdir(path string, perm uint32) error { + fs.mu.Lock() + defer fs.mu.Unlock() + _, err := fs.open(path, O_CREATE|O_EXCL, perm&0777|S_IFDIR) + return err +} + +func Getcwd(buf []byte) (n int, err error) { + // Force package os to default to the old algorithm using .. and directory reads. + return 0, ENOSYS +} + +func Stat(path string, st *Stat_t) error { + fs.mu.Lock() + defer fs.mu.Unlock() + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + *st = ip.Stat_t + return nil +} + +func Lstat(path string, st *Stat_t) error { + return Stat(path, st) +} + +func unlink(path string, isdir bool) error { + fs.mu.Lock() + defer fs.mu.Unlock() + dp, elem, err := fs.namei(path, true) + if err != nil { + return err + } + if elem == "." || elem == ".." { + return EINVAL + } + de, _, err := fs.dirlookup(dp, elem) + if err != nil { + return err + } + if isdir { + if de.inode.Mode&S_IFMT != S_IFDIR { + return ENOTDIR + } + if len(de.inode.dir) != 2 { + return ENOTEMPTY + } + } else { + if de.inode.Mode&S_IFMT == S_IFDIR { + return EISDIR + } + } + de.inode.Nlink-- + *de = dp.dir[len(dp.dir)-1] + dp.dir = dp.dir[:len(dp.dir)-1] + dp.dirSize() + return nil +} + +func Unlink(path string) error { + return unlink(path, false) +} + +func Rmdir(path string) error { + return unlink(path, true) +} + +func Chmod(path string, mode uint32) error { + fs.mu.Lock() + defer fs.mu.Unlock() + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + ip.Mode = ip.Mode&^0777 | mode&0777 + return nil +} + +func Fchmod(fd int, mode uint32) error { + f, err := fdToFsysFile(fd) + if err != nil { + return err + } + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + f.inode.Mode = f.inode.Mode&^0777 | mode&0777 + return nil +} + +func Chown(path string, uid, gid int) error { + fs.mu.Lock() + defer fs.mu.Unlock() + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + ip.Uid = uint32(uid) + ip.Gid = uint32(gid) + return nil +} + +func Fchown(fd int, uid, gid int) error { + fs.mu.Lock() + defer fs.mu.Unlock() + f, err := fdToFsysFile(fd) + if err != nil { + return err + } + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + f.inode.Uid = uint32(uid) + f.inode.Gid = uint32(gid) + return nil +} + +func Lchown(path string, uid, gid int) error { + return Chown(path, uid, gid) +} + +func UtimesNano(path string, ts []Timespec) error { + if len(ts) != 2 { + return EINVAL + } + fs.mu.Lock() + defer fs.mu.Unlock() + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + ip.Atime = ts[0].Sec + ip.AtimeNsec = int64(ts[0].Nsec) + ip.Mtime = ts[1].Sec + ip.MtimeNsec = int64(ts[1].Nsec) + return nil +} + +func Link(path, link string) error { + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + dp, elem, err := fs.namei(link, true) + if err != nil { + return err + } + if ip.Mode&S_IFMT == S_IFDIR { + return EPERM + } + fs.dirlink(dp, elem, ip) + return nil +} + +func Rename(from, to string) error { + fdp, felem, err := fs.namei(from, true) + if err != nil { + return err + } + fde, _, err := fs.dirlookup(fdp, felem) + if err != nil { + return err + } + tdp, telem, err := fs.namei(to, true) + if err != nil { + return err + } + fs.dirlink(tdp, telem, fde.inode) + fde.inode.Nlink-- + *fde = fdp.dir[len(fdp.dir)-1] + fdp.dir = fdp.dir[:len(fdp.dir)-1] + fdp.dirSize() + return nil +} + +func (fs *fsys) truncate(ip *inode, length int64) error { + if length > 1e9 || ip.Mode&S_IFMT != S_IFREG { + return EINVAL + } + if length < int64(len(ip.data)) { + ip.data = ip.data[:length] + } else { + data := make([]byte, length) + copy(data, ip.data) + ip.data = data + } + ip.Size = int64(len(ip.data)) + return nil +} + +func Truncate(path string, length int64) error { + fs.mu.Lock() + defer fs.mu.Unlock() + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + return fs.truncate(ip, length) +} + +func Ftruncate(fd int, length int64) error { + f, err := fdToFsysFile(fd) + if err != nil { + return err + } + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + return f.fsys.truncate(f.inode, length) +} + +func Chdir(path string) error { + fs.mu.Lock() + defer fs.mu.Unlock() + ip, _, err := fs.namei(path, false) + if err != nil { + return err + } + fs.cwd = ip + return nil +} + +func Fchdir(fd int) error { + f, err := fdToFsysFile(fd) + if err != nil { + return err + } + f.fsys.mu.Lock() + defer f.fsys.mu.Unlock() + if f.inode.Mode&S_IFMT != S_IFDIR { + return ENOTDIR + } + fs.cwd = f.inode + return nil +} + +func Readlink(path string, buf []byte) (n int, err error) { + return 0, ENOSYS +} + +func Symlink(path, link string) error { + return ENOSYS +} + +func Fsync(fd int) error { + return nil +} + +// Special devices. + +func mkdev(path string, mode uint32, open func() (devFile, error)) error { + fs.mu.Lock() + fs.mu.Unlock() + f, err := fs.open(path, O_CREATE|O_RDONLY|O_EXCL, S_IFCHR|mode) + if err != nil { + return err + } + ip := f.(*fsysFile).inode + ip.Rdev = int64(len(fs.dev)) + fs.dev = append(fs.dev, open) + return nil +} + +type nullFile struct{} + +func openNull() (devFile, error) { return &nullFile{}, nil } +func (f *nullFile) close() error { return nil } +func (f *nullFile) pread(b []byte, offset int64) (int, error) { return 0, nil } +func (f *nullFile) pwrite(b []byte, offset int64) (int, error) { return len(b), nil } + +type zeroFile struct{} + +func openZero() (devFile, error) { return &zeroFile{}, nil } +func (f *zeroFile) close() error { return nil } +func (f *zeroFile) pwrite(b []byte, offset int64) (int, error) { return len(b), nil } + +func (f *zeroFile) pread(b []byte, offset int64) (int, error) { + for i := range b { + b[i] = 0 + } + return len(b), nil +} + +type randomFile struct { + naclFD int +} + +func openRandom() (devFile, error) { + fd, err := openNamedService("SecureRandom", O_RDONLY) + if err != nil { + return nil, err + } + return &randomFile{naclFD: fd}, nil +} + +func (f *randomFile) close() error { + naclClose(f.naclFD) + f.naclFD = -1 + return nil +} + +func (f *randomFile) pread(b []byte, offset int64) (int, error) { + return naclRead(f.naclFD, b) +} + +func (f *randomFile) pwrite(b []byte, offset int64) (int, error) { + return 0, EPERM +} + +func fdToFsysFile(fd int) (*fsysFile, error) { + f, err := fdToFile(fd) + if err != nil { + return nil, err + } + impl := f.impl + fsysf, ok := impl.(*fsysFile) + if !ok { + return nil, EINVAL + } + return fsysf, nil +} + +// create creates a file in the file system with the given name, mode, time, and data. +// It is meant to be called when initializing the file system image. +func create(name string, mode uint32, sec int64, data []byte) error { + fs.mu.Lock() + fs.mu.Unlock() + f, err := fs.open(name, O_CREATE|O_EXCL, mode) + if err != nil { + return err + } + ip := f.(*fsysFile).inode + ip.Atime = sec + ip.Mtime = sec + ip.Ctime = sec + if len(data) > 0 { + ip.Size = int64(len(data)) + ip.data = data + } + return nil +} diff --git a/src/pkg/syscall/lsf_linux.go b/src/pkg/syscall/lsf_linux.go index 05d653b4a..ee07fea3f 100644 --- a/src/pkg/syscall/lsf_linux.go +++ b/src/pkg/syscall/lsf_linux.go @@ -69,10 +69,10 @@ func AttachLsf(fd int, i []SockFilter) error { var p SockFprog p.Len = uint16(len(i)) p.Filter = (*SockFilter)(unsafe.Pointer(&i[0])) - return setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, uintptr(unsafe.Pointer(&p)), unsafe.Sizeof(p)) + return setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, unsafe.Pointer(&p), unsafe.Sizeof(p)) } func DetachLsf(fd int) error { var dummy int - return setsockopt(fd, SOL_SOCKET, SO_DETACH_FILTER, uintptr(unsafe.Pointer(&dummy)), unsafe.Sizeof(dummy)) + return setsockopt(fd, SOL_SOCKET, SO_DETACH_FILTER, unsafe.Pointer(&dummy), unsafe.Sizeof(dummy)) } diff --git a/src/pkg/syscall/mkall.sh b/src/pkg/syscall/mkall.sh index a3139d603..886db133c 100755 --- a/src/pkg/syscall/mkall.sh +++ b/src/pkg/syscall/mkall.sh @@ -81,6 +81,8 @@ mkerrors="./mkerrors.sh" zerrors="zerrors_$GOOSARCH.go" mksysctl="" zsysctl="zsysctl_$GOOSARCH.go" +mksysnum= +mktypes= run="sh" case "$1" in @@ -136,19 +138,21 @@ dragonfly_amd64) freebsd_386) mkerrors="$mkerrors -m32" mksyscall="./mksyscall.pl -l32" - mksysnum="curl -s 'http://svn.freebsd.org/base/head/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl" + mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl" mktypes="GOARCH=$GOARCH go tool cgo -godefs" ;; freebsd_amd64) mkerrors="$mkerrors -m64" - mksysnum="curl -s 'http://svn.freebsd.org/base/head/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl" + mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl" mktypes="GOARCH=$GOARCH go tool cgo -godefs" ;; freebsd_arm) mkerrors="$mkerrors" mksyscall="./mksyscall.pl -l32 -arm" - mksysnum="curl -s 'http://svn.freebsd.org/base/head/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl" - mktypes="GOARCH=$GOARCH go tool cgo -godefs" + mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' | ./mksysnum_freebsd.pl" + # Let the type of C char be singed for making the bare syscall + # API consistent across over platforms. + mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char" ;; linux_386) mkerrors="$mkerrors -m32" @@ -172,6 +176,18 @@ linux_arm) mksysnum="curl -s 'http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/plain/arch/arm/include/uapi/asm/unistd.h' | ./mksysnum_linux.pl" mktypes="GOARCH=$GOARCH go tool cgo -godefs" ;; +nacl_386) + mkerrors="" + mksyscall="./mksyscall.pl -l32 -nacl" + mksysnum="" + mktypes="" + ;; +nacl_amd64p32) + mkerrors="" + mksyscall="./mksyscall.pl -nacl" + mksysnum="" + mktypes="" + ;; netbsd_386) mkerrors="$mkerrors -m32" mksyscall="./mksyscall.pl -l32 -netbsd" @@ -206,19 +222,16 @@ plan9_386) mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h" mktypes="XXX" ;; -windows_386) - mksyscall="./mksyscall_windows.pl -l32" +solaris_amd64) + mksyscall="./mksyscall_solaris.pl" + mkerrors="$mkerrors -m64" mksysnum= - mktypes= - mkerrors="./mkerrors_windows.sh -m32" - zerrors="zerrors_windows.go" + mktypes="GOARCH=$GOARCH go tool cgo -godefs" ;; -windows_amd64) - mksyscall="./mksyscall_windows.pl" - mksysnum= - mktypes= - mkerrors="./mkerrors_windows.sh -m32" - zerrors="zerrors_windows.go" +windows_*) + mksyscall= + mkerrors= + zerrors= ;; *) echo 'unrecognized $GOOS_$GOARCH: ' "$GOOSARCH" 1>&2 @@ -228,17 +241,23 @@ esac ( if [ -n "$mkerrors" ]; then echo "$mkerrors |gofmt >$zerrors"; fi - syscall_goos="syscall_$GOOS.go" case "$GOOS" in - darwin | dragonfly | freebsd | netbsd | openbsd) - syscall_goos="syscall_bsd.go $syscall_goos" - ;; windows) - syscall_goos="$syscall_goos security_windows.go" + echo "GOOS= GOARCH= go build mksyscall_windows.go" + echo "./mksyscall_windows syscall_windows.go security_windows.go syscall_$GOOSARCH.go |gofmt >zsyscall_$GOOSARCH.go" + echo "rm -f ./mksyscall_windows" + ;; + *) + syscall_goos="syscall_$GOOS.go" + case "$GOOS" in + darwin | dragonfly | freebsd | netbsd | openbsd) + syscall_goos="syscall_bsd.go $syscall_goos" + ;; + esac + if [ -n "$mksyscall" ]; then echo "$mksyscall $syscall_goos syscall_$GOOSARCH.go |gofmt >zsyscall_$GOOSARCH.go"; fi ;; esac if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi - if [ -n "$mksyscall" ]; then echo "$mksyscall $syscall_goos syscall_$GOOSARCH.go |gofmt >zsyscall_$GOOSARCH.go"; fi if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi if [ -n "$mktypes" ]; then echo "$mktypes types_$GOOS.go |gofmt >ztypes_$GOOSARCH.go"; fi ) | $run diff --git a/src/pkg/syscall/mkall_windows.bat b/src/pkg/syscall/mkall_windows.bat new file mode 100644 index 000000000..a4a3f1674 --- /dev/null +++ b/src/pkg/syscall/mkall_windows.bat @@ -0,0 +1,21 @@ +:: Copyright 2013 The Go Authors. All rights reserved. +:: Use of this source code is governed by a BSD-style +:: license that can be found in the LICENSE file. +@echo off + +if exist mkall.sh goto dirok +echo mkall_windows.bat must be run from src\pkg\syscall directory +goto :end +:dirok + +if "%1"=="386" goto :paramok +if "%1"=="amd64" goto :paramok +echo parameters must be 386 or amd64 +goto :end +:paramok + +go build mksyscall_windows.go +.\mksyscall_windows syscall_windows.go security_windows.go syscall_windows_%1.go |gofmt >zsyscall_windows_%1.go +del mksyscall_windows.exe + +:end
\ No newline at end of file diff --git a/src/pkg/syscall/mkerrors.sh b/src/pkg/syscall/mkerrors.sh index 20b2b9875..cf0afe0bd 100755 --- a/src/pkg/syscall/mkerrors.sh +++ b/src/pkg/syscall/mkerrors.sh @@ -11,7 +11,7 @@ unset LANG export LC_ALL=C export LC_CTYPE=C -GCC=gcc +CC=${CC:-gcc} uname=$(uname) @@ -57,6 +57,7 @@ includes_DragonFly=' ' includes_FreeBSD=' +#include <sys/param.h> #include <sys/types.h> #include <sys/event.h> #include <sys/socket.h> @@ -73,6 +74,14 @@ includes_FreeBSD=' #include <termios.h> #include <netinet/ip.h> #include <netinet/ip_mroute.h> + +#if __FreeBSD__ >= 10 +#define IFT_CARP 0xf8 // IFT_CARP is deprecated in FreeBSD 10 +#undef SIOCAIFADDR +#define SIOCAIFADDR _IOW(105, 26, struct oifaliasreq) // ifaliasreq contains if_data +#undef SIOCSIFPHYADDR +#define SIOCSIFPHYADDR _IOW(105, 70, struct oifaliasreq) // ifaliasreq contains if_data +#endif ' includes_Linux=' @@ -92,9 +101,12 @@ includes_Linux=' #include <sys/types.h> #include <sys/time.h> #include <sys/socket.h> -#include <linux/if_addr.h> +#include <linux/if.h> +#include <linux/if_arp.h> #include <linux/if_ether.h> #include <linux/if_tun.h> +#include <linux/if_packet.h> +#include <linux/if_addr.h> #include <linux/filter.h> #include <linux/netlink.h> #include <linux/reboot.h> @@ -103,10 +115,7 @@ includes_Linux=' #include <linux/sched.h> #include <linux/wait.h> #include <linux/icmpv6.h> -#include <net/if.h> -#include <net/if_arp.h> #include <net/route.h> -#include <netpacket/packet.h> #include <termios.h> #ifndef MSG_FASTOPEN @@ -118,6 +127,7 @@ includes_NetBSD=' #include <sys/types.h> #include <sys/param.h> #include <sys/event.h> +#include <sys/mman.h> #include <sys/socket.h> #include <sys/sockio.h> #include <sys/sysctl.h> @@ -142,6 +152,7 @@ includes_OpenBSD=' #include <sys/types.h> #include <sys/param.h> #include <sys/event.h> +#include <sys/mman.h> #include <sys/socket.h> #include <sys/sockio.h> #include <sys/sysctl.h> @@ -151,6 +162,7 @@ includes_OpenBSD=' #include <net/bpf.h> #include <net/if.h> #include <net/if_types.h> +#include <net/if_var.h> #include <net/route.h> #include <netinet/in.h> #include <netinet/in_systm.h> @@ -158,6 +170,36 @@ includes_OpenBSD=' #include <netinet/ip_mroute.h> #include <netinet/if_ether.h> #include <net/if_bridge.h> + +// We keep some constants not supported in OpenBSD 5.5 and beyond for +// the promise of compatibility. +#define EMUL_ENABLED 0x1 +#define EMUL_NATIVE 0x2 +#define IPV6_FAITH 0x1d +#define IPV6_OPTIONS 0x1 +#define IPV6_RTHDR_STRICT 0x1 +#define IPV6_SOCKOPT_RESERVED1 0x3 +#define SIOCGIFGENERIC 0xc020693a +#define SIOCSIFGENERIC 0x80206939 +#define WALTSIG 0x4 +' + +includes_SunOS=' +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <sys/mman.h> +#include <sys/wait.h> +#include <sys/ioctl.h> +#include <net/bpf.h> +#include <net/if.h> +#include <net/if_arp.h> +#include <net/if_types.h> +#include <net/route.h> +#include <netinet/in.h> +#include <termios.h> +#include <netinet/ip.h> +#include <netinet/ip_mroute.h> ' includes=' @@ -192,7 +234,7 @@ ccflags="$@" # The gcc command line prints all the #defines # it encounters while processing the input - echo "${!indirect} $includes" | $GCC -x c - -E -dM $ccflags | + echo "${!indirect} $includes" | $CC -x c - -E -dM $ccflags | awk ' $1 != "#define" || $2 ~ /\(/ || $3 == "" {next} @@ -240,6 +282,7 @@ ccflags="$@" $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P)_/ || $2 ~ /^SIOC/ || $2 ~ /^TIOC/ || + $2 !~ "RTF_BITS" && $2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ || $2 ~ /^BIOC/ || $2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ || @@ -261,24 +304,24 @@ ccflags="$@" # Pull out the error names for later. errors=$( - echo '#include <errno.h>' | $GCC -x c - -E -dM $ccflags | + echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags | awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print $2 }' | sort ) # Pull out the signal names for later. signals=$( - echo '#include <signal.h>' | $GCC -x c - -E -dM $ccflags | + echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags | awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' | egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' | sort ) # Again, writing regexps to a file. -echo '#include <errno.h>' | $GCC -x c - -E -dM $ccflags | +echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags | awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print "^\t" $2 "[ \t]*=" }' | sort >_error.grep -echo '#include <signal.h>' | $GCC -x c - -E -dM $ccflags | +echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags | awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' | egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' | sort >_signal.grep @@ -302,8 +345,9 @@ echo ')' # Run C program to print error and syscall strings. ( - /bin/echo " + echo -E " #include <stdio.h> +#include <stdlib.h> #include <errno.h> #include <ctype.h> #include <string.h> @@ -317,22 +361,21 @@ int errors[] = { " for i in $errors do - /bin/echo ' '$i, + echo -E ' '$i, done - /bin/echo " + echo -E " }; int signals[] = { " for i in $signals do - /bin/echo ' '$i, + echo -E ' '$i, done - # Use /bin/echo to avoid builtin echo, - # which interprets \n itself - /bin/echo ' + # Use -E because on some systems bash builtin interprets \n itself. + echo -E ' }; static int @@ -387,4 +430,4 @@ main(void) ' ) >_errors.c -$GCC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out +$CC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out diff --git a/src/pkg/syscall/mkerrors_windows.sh b/src/pkg/syscall/mkerrors_windows.sh deleted file mode 100755 index 13badcd92..000000000 --- a/src/pkg/syscall/mkerrors_windows.sh +++ /dev/null @@ -1,202 +0,0 @@ -#!/usr/bin/env bash -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -# Generate Go code listing errors and other #defined constant -# values (ENAMETOOLONG etc.), by asking the preprocessor -# about the definitions. - -unset LANG -export LC_ALL=C -export LC_CTYPE=C - -case "$GOARCH" in -arm) - GCC=arm-gcc - ;; -*) - GCC=gcc - ;; -esac - -uname=$(uname) - -includes_Linux=' -#define _LARGEFILE_SOURCE -#define _LARGEFILE64_SOURCE -#define _FILE_OFFSET_BITS 64 -#define _GNU_SOURCE - -#include <sys/types.h> -#include <sys/epoll.h> -#include <linux/ptrace.h> -#include <linux/wait.h> -' - -includes_Darwin=' -#define __DARWIN_UNIX03 0 -#define KERNEL -#define _DARWIN_USE_64_BIT_INODE -#include <sys/wait.h> -#include <sys/event.h> -' - -includes_FreeBSD=' -#include <sys/wait.h> -#include <sys/event.h> -' - -includes=' -#include <sys/types.h> -#include <fcntl.h> -#include <dirent.h> -#include <sys/socket.h> -#include <netinet/in.h> -#include <netinet/ip.h> -#include <netinet/ip6.h> -#include <netinet/tcp.h> -#include <errno.h> -#include <sys/signal.h> -#include <signal.h> -' - -ccflags="" -next=false -for i -do - if $next; then - ccflags="$ccflags $i" - next=false - elif [ "$i" = "-f" ]; then - next=true - fi -done - -# These are go errors that will be mapped directly to windows errors -goerrors=' -ENOENT:ERROR_FILE_NOT_FOUND -ENOTDIR:ERROR_PATH_NOT_FOUND -' - -# Pull out just the error names for later. -i=$( - for j in "$goerrors" - do - echo "$j" - done | - awk -F: ' - { if (NR > 1) printf("|") } - { printf("%s", $1) } - ' -) -errors=$( - echo '#include <errno.h>' | $GCC -x c - -E -dM $ccflags | - awk ' - $1 != "#define" || $2 ~ /\(/ {next} - $2 ~ /^('$i')$/ {next} - $2 ~ /^E[A-Z0-9_]+$/ { print $2 } - {next} - ' | sort -) - -echo '// mkerrors_windows.sh' "$@" -echo '// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT' -echo -echo 'package syscall' - -# Run C program to print error strings. -( - /bin/echo " -#include <stdio.h> -#include <errno.h> -#include <ctype.h> -#include <string.h> - -#define nelem(x) (sizeof(x)/sizeof((x)[0])) - -enum { A = 'A', Z = 'Z', a = 'a', z = 'z' }; // avoid need for single quotes below - -struct { - char *goname; - char *winname; -} goerrors[] = { -" - for i in $goerrors - do - j=`echo $i | cut -d: -f1` - k=`echo $i | cut -d: -f2` - echo ' {"'$j'", "'$k'"},' - done - - # Use /bin/echo to avoid builtin echo, - # which interprets \n itself - /bin/echo ' -}; - -struct { - char *name; - int value; -} errors[] = { -' - for i in $errors - do - echo ' {"'$i'",' $i'},' - done - - # Use /bin/echo to avoid builtin echo, - # which interprets \n itself - /bin/echo ' -}; - -int -main(void) -{ - int i, e, iota = 1; - char buf[1024]; - - printf("\n// Go names for Windows errors.\n"); - printf("const (\n"); - for(i=0; i<nelem(goerrors); i++) { - printf("\t%s Errno = %s\n", goerrors[i].goname, goerrors[i].winname); - - } - printf(")\n"); - - printf("\n// Windows reserves errors >= 1<<29 for application use.\n"); - printf("const APPLICATION_ERROR = 1 << 29\n"); - - printf("\n// Invented values to support what package os and others expects.\n"); - printf("const (\n"); - for(i=0; i<nelem(errors); i++) { - printf("\t%s", errors[i].name); - if(iota) { - printf(" Errno = APPLICATION_ERROR + iota"); - iota = !iota; - } - printf("\n"); - - } - printf("\tEWINDOWS\n"); - printf(")\n"); - - printf("\n// Error strings for invented errors\n"); - printf("var errors = [...]string {\n"); - for(i=0; i<nelem(errors); i++) { - e = errors[i].value; - strcpy(buf, strerror(e)); - // lowercase first letter: Bad -> bad, but STREAM -> STREAM. - if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z) - buf[0] += a - A; - printf("\t%s - APPLICATION_ERROR: \"%s\",\n", errors[i].name, buf); - next:; - } - printf("\tEWINDOWS - APPLICATION_ERROR: \"not supported by windows\",\n"); - printf("}\n\n"); - return 0; -} - -' -) >_errors.c - -$GCC $ccflags -static -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors diff --git a/src/pkg/syscall/mksyscall.pl b/src/pkg/syscall/mksyscall.pl index b4ece9a54..6d35fa689 100755 --- a/src/pkg/syscall/mksyscall.pl +++ b/src/pkg/syscall/mksyscall.pl @@ -28,6 +28,7 @@ my $plan9 = 0; my $openbsd = 0; my $netbsd = 0; my $dragonfly = 0; +my $nacl = 0; my $arm = 0; # 64-bit value should use (even, odd)-pair if($ARGV[0] eq "-b32") { @@ -53,6 +54,10 @@ if($ARGV[0] eq "-dragonfly") { $dragonfly = 1; shift; } +if($ARGV[0] eq "-nacl") { + $nacl = 1; + shift; +} if($ARGV[0] eq "-arm") { $arm = 1; shift; @@ -95,7 +100,7 @@ while(<>) { # Line must be of the form # func Open(path string, mode int, perm int) (fd int, errno error) # Split into name, in params, out params. - if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(SYS_[A-Z0-9_]+))?$/) { + if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$/) { print STDERR "$ARGV:$.: malformed //sys declaration\n"; $errors = 1; next; @@ -219,6 +224,9 @@ while(<>) { $sysname = "SYS_$func"; $sysname =~ s/([a-z])([A-Z])/${1}_$2/g; # turn FooBar into Foo_Bar $sysname =~ y/a-z/A-Z/; + if($nacl) { + $sysname =~ y/A-Z/a-z/; + } } # Actual call. diff --git a/src/pkg/syscall/mksyscall_windows.pl b/src/pkg/syscall/mksyscall_solaris.pl index 65d6efc20..130d043d9 100755 --- a/src/pkg/syscall/mksyscall_windows.pl +++ b/src/pkg/syscall/mksyscall_solaris.pl @@ -4,7 +4,7 @@ # license that can be found in the LICENSE file. # This program reads a file containing function prototypes -# (like syscall_darwin.go) and generates system call bodies. +# (like syscall_solaris.go) and generates system call bodies. # The prototypes are marked by lines beginning with "//sys" # and read like func declarations if //sys is replaced by func, but: # * The parameter lists must give a name for each argument. @@ -12,20 +12,14 @@ # * The parameter lists must give a type for each argument: # the (x, y, z int) shorthand is not allowed. # * If the return parameter is an error number, it must be named err. -# * If go func name needs to be different from it's winapi dll name, -# the winapi name could be specified at the end, after "=" sign, like -# //sys LoadLibrary(libname string) (handle uint32, err error) = LoadLibraryA -# * Each function that returns err needs to supply a condition, -# that return value of winapi will be tested against to -# detect failure. This would set err to windows "last-error", -# otherwise it will be nil. The value can be provided -# at end of //sys declaration, like -# //sys LoadLibrary(libname string) (handle uint32, err error) [failretval==-1] = LoadLibraryA -# and is [failretval==0] by default. +# * If go func name needs to be different than its libc name, +# * or the function is not in libc, name could be specified +# * at the end, after "=" sign, like +# //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt use strict; -my $cmdline = "mksyscall_windows.pl " . join(' ', @ARGV); +my $cmdline = "mksyscall_solaris.pl " . join(' ', @ARGV); my $errors = 0; my $_32bit = ""; @@ -40,7 +34,7 @@ if($ARGV[0] eq "-b32") { } if($ARGV[0] =~ /^-/) { - print STDERR "usage: mksyscall_windows.pl [-b32 | -l32] [file ...]\n"; + print STDERR "usage: mksyscall_solaris.pl [-b32 | -l32] [file ...]\n"; exit 1; } @@ -75,7 +69,8 @@ while(<>) { s/^\s+//; s/\s+$//; $package = $1 if !$package && /^package (\S+)$/; - next if !/^\/\/sys /; + my $nonblock = /^\/\/sysnb /; + next if !/^\/\/sys / && !$nonblock; my $syscalldot = ""; $syscalldot = "syscall." if $package ne "syscall"; @@ -83,25 +78,25 @@ while(<>) { # Line must be of the form # func Open(path string, mode int, perm int) (fd int, err error) # Split into name, in params, out params. - if(!/^\/\/sys (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:\[failretval(.*)\])?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$/) { + if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$/) { print STDERR "$ARGV:$.: malformed //sys declaration\n"; $errors = 1; next; } - my ($func, $in, $out, $failcond, $modname, $sysname) = ($1, $2, $3, $4, $5, $6); + my ($nb, $func, $in, $out, $modname, $sysname) = ($1, $2, $3, $4, $5, $6); # Split argument lists on comma. my @in = parseparamlist($in); my @out = parseparamlist($out); - # Dll file name. + # So file name. if($modname eq "") { - $modname = "kernel32"; + $modname = "libc"; } my $modvname = "mod$modname"; if($modnames !~ /$modname/) { $modnames .= ".$modname"; - $mods .= "\t$modvname = ${syscalldot}NewLazyDLL(\"$modname.dll\")\n"; + $mods .= "\t$modvname = ${syscalldot}newLazySO(\"$modname.so\")\n"; } # System call name. @@ -112,16 +107,11 @@ while(<>) { # System call pointer variable name. my $sysvarname = "proc$sysname"; - # Returned value when failed - if($failcond eq "") { - $failcond = "== 0"; - } - - # Decide which version of api is used: ascii or unicode. - my $strconvfunc = $sysname !~ /W$/ ? "BytePtrFromString" : "UTF16PtrFromString"; - my $strconvtype = $sysname !~ /W$/ ? "*byte" : "*uint16"; + my $strconvfunc = "BytePtrFromString"; + my $strconvtype = "*byte"; - # Winapi proc address variable. + # Library proc address variable. + $sysname =~ y/A-Z/a-z/; # All libc functions are lowercase. $vars .= "\t$sysvarname = $modvname.NewProc(\"$sysname\")\n"; # Go function header. @@ -191,31 +181,14 @@ while(<>) { my $nargs = @args; # Determine which form to use; pad args with zeros. - my $asm = "${syscalldot}Syscall"; - if(@args <= 3) { - while(@args < 3) { - push @args, "0"; - } - } elsif(@args <= 6) { - $asm = "${syscalldot}Syscall6"; + my $asm = "${syscalldot}sysvicall6"; + if ($nonblock) { + $asm = "${syscalldot}rawSysvicall6"; + } + if(@args <= 6) { while(@args < 6) { push @args, "0"; } - } elsif(@args <= 9) { - $asm = "${syscalldot}Syscall9"; - while(@args < 9) { - push @args, "0"; - } - } elsif(@args <= 12) { - $asm = "${syscalldot}Syscall12"; - while(@args < 12) { - push @args, "0"; - } - } elsif(@args <= 15) { - $asm = "${syscalldot}Syscall15"; - while(@args < 15) { - push @args, "0"; - } } else { print STDERR "$ARGV:$.: too many arguments to system call\n"; } @@ -229,6 +202,7 @@ while(<>) { my $failexpr = ""; my @ret = ("_", "_", "_"); my @pout= (); + my $do_errno = 0; for(my $i=0; $i<@out; $i++) { my $p = $out[$i]; my ($name, $type) = parseparam($p); @@ -236,6 +210,7 @@ while(<>) { if($name eq "err") { $reg = "e1"; $ret[2] = $reg; + $do_errno = 1; } else { $reg = sprintf("r%d", $i); $ret[$i] = $reg; @@ -256,40 +231,9 @@ while(<>) { $ret[$i] = sprintf("r%d", $i); $ret[$i+1] = sprintf("r%d", $i+1); } - my $rettype = $type; - if($type =~ /^\*/) { - $reg = "unsafe.Pointer($reg)"; - $rettype = "($rettype)"; - } - if($i == 0) { - if($type eq "bool") { - $failexpr = "!$name"; - } elsif($name eq "err") { - $ret[$i] = "r1"; - $failexpr = "r1 $failcond"; - } else { - $failexpr = "$name $failcond"; - } - } - $failexpr =~ s/(=)([0-9A-Za-z\-+])/$1 $2/; # gofmt compatible - if($name eq "err") { - # Set err to "last error" only if returned value indicate failure - $body .= "\tif $failexpr {\n"; - $body .= "\t\tif $reg != 0 {\n"; - $body .= "\t\t\t$name = $type($reg)\n"; - $body .= "\t\t} else {\n"; - $body .= "\t\t\t$name = ${syscalldot}EINVAL\n"; - $body .= "\t\t}\n"; - $body .= "\t}\n"; - } elsif($rettype eq "error") { - # Set $reg to "error" only if returned value indicate failure - $body .= "\tif $reg != 0 {\n"; - $body .= "\t\t$name = ${syscalldot}Errno($reg)\n"; - $body .= "\t}\n"; - } else { - $body .= "\t$name = $rettype($reg)\n"; + if($reg ne "e1") { + $body .= "\t$name = $type($reg)\n"; } - push @pout, sprintf "\"%s=\", %s, ", $name, $name; } if ($ret[0] eq "_" && $ret[1] eq "_" && $ret[2] eq "_") { $text .= "\t$call\n"; @@ -297,10 +241,12 @@ while(<>) { $text .= "\t$ret[0], $ret[1], $ret[2] := $call\n"; } $text .= $body; - if(0) { - $text .= sprintf 'print("SYSCALL: %s(", %s") (", %s")\n")%s', $func, join('", ", ', @pin), join('", ", ', @pout), "\n"; - } + if ($do_errno) { + $text .= "\tif e1 != 0 {\n"; + $text .= "\t\terr = e1\n"; + $text .= "\t}\n"; + } $text .= "\treturn\n"; $text .= "}\n"; } diff --git a/src/pkg/syscall/mksyscall_windows.go b/src/pkg/syscall/mksyscall_windows.go new file mode 100644 index 000000000..4225588de --- /dev/null +++ b/src/pkg/syscall/mksyscall_windows.go @@ -0,0 +1,662 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +/* +mksyscall_windows generates windows system call bodies + +It parses all files specified on command line containing function +prototypes (like syscall_windows.go) and prints system call bodies +to standard output. + +The prototypes are marked by lines beginning with "//sys" and read +like func declarations if //sys is replaced by func, but: + +* The parameter lists must give a name for each argument. This + includes return parameters. + +* The parameter lists must give a type for each argument: + the (x, y, z int) shorthand is not allowed. + +* If the return parameter is an error number, it must be named err. + +* If go func name needs to be different from it's winapi dll name, + the winapi name could be specified at the end, after "=" sign, like + //sys LoadLibrary(libname string) (handle uint32, err error) = LoadLibraryA + +* Each function that returns err needs to supply a condition, that + return value of winapi will be tested against to detect failure. + This would set err to windows "last-error", otherwise it will be nil. + The value can be provided at end of //sys declaration, like + //sys LoadLibrary(libname string) (handle uint32, err error) [failretval==-1] = LoadLibraryA + and is [failretval==0] by default. + +Usage: + mksyscall_windows [flags] [path ...] + +The flags are: + -trace + Generate print statement after every syscall. +*/ +package main + +import ( + "bufio" + "errors" + "flag" + "fmt" + "io" + "log" + "os" + "strconv" + "strings" + "text/template" +) + +var PrintTraceFlag = flag.Bool("trace", false, "generate print statement after every syscall") + +func trim(s string) string { + return strings.Trim(s, " \t") +} + +// Param is function parameter +type Param struct { + Name string + Type string + fn *Fn + tmpVarIdx int +} + +// tmpVar returns temp variable name that will be used to represent p during syscall. +func (p *Param) tmpVar() string { + if p.tmpVarIdx < 0 { + p.tmpVarIdx = p.fn.curTmpVarIdx + p.fn.curTmpVarIdx++ + } + return fmt.Sprintf("_p%d", p.tmpVarIdx) +} + +// BoolTmpVarCode returns source code for bool temp variable. +func (p *Param) BoolTmpVarCode() string { + const code = `var %s uint32 + if %s { + %s = 1 + } else { + %s = 0 + }` + tmp := p.tmpVar() + return fmt.Sprintf(code, tmp, p.Name, tmp, tmp) +} + +// SliceTmpVarCode returns source code for slice temp variable. +func (p *Param) SliceTmpVarCode() string { + const code = `var %s *%s + if len(%s) > 0 { + %s = &%s[0] + }` + tmp := p.tmpVar() + return fmt.Sprintf(code, tmp, p.Type[2:], p.Name, tmp, p.Name) +} + +// StringTmpVarCode returns source code for string temp variable. +func (p *Param) StringTmpVarCode() string { + errvar := p.fn.Rets.ErrorVarName() + if errvar == "" { + errvar = "_" + } + tmp := p.tmpVar() + const code = `var %s %s + %s, %s = %s(%s)` + s := fmt.Sprintf(code, tmp, p.fn.StrconvType(), tmp, errvar, p.fn.StrconvFunc(), p.Name) + if errvar == "-" { + return s + } + const morecode = ` + if %s != nil { + return + }` + return s + fmt.Sprintf(morecode, errvar) +} + +// TmpVarCode returns source code for temp variable. +func (p *Param) TmpVarCode() string { + switch { + case p.Type == "string": + return p.StringTmpVarCode() + case p.Type == "bool": + return p.BoolTmpVarCode() + case strings.HasPrefix(p.Type, "[]"): + return p.SliceTmpVarCode() + default: + return "" + } +} + +// SyscallArgList returns source code fragments representing p parameter +// in syscall. Slices are translated into 2 syscall parameters: pointer to +// the first element and length. +func (p *Param) SyscallArgList() []string { + var s string + switch { + case p.Type[0] == '*': + s = fmt.Sprintf("unsafe.Pointer(%s)", p.Name) + case p.Type == "string": + s = fmt.Sprintf("unsafe.Pointer(%s)", p.tmpVar()) + case p.Type == "bool": + s = p.tmpVar() + case strings.HasPrefix(p.Type, "[]"): + return []string{ + fmt.Sprintf("uintptr(unsafe.Pointer(%s))", p.tmpVar()), + fmt.Sprintf("uintptr(len(%s))", p.Name), + } + default: + s = p.Name + } + return []string{fmt.Sprintf("uintptr(%s)", s)} +} + +// IsError determines if p parameter is used to return error. +func (p *Param) IsError() bool { + return p.Name == "err" && p.Type == "error" +} + +// join concatenates parameters ps into a string with sep separator. +// Each parameter is converted into string by applying fn to it +// before conversion. +func join(ps []*Param, fn func(*Param) string, sep string) string { + if len(ps) == 0 { + return "" + } + a := make([]string, 0) + for _, p := range ps { + a = append(a, fn(p)) + } + return strings.Join(a, sep) +} + +// Rets describes function return parameters. +type Rets struct { + Name string + Type string + ReturnsError bool + FailCond string +} + +// ErrorVarName returns error variable name for r. +func (r *Rets) ErrorVarName() string { + if r.ReturnsError { + return "err" + } + if r.Type == "error" { + return r.Name + } + return "" +} + +// ToParams converts r into slice of *Param. +func (r *Rets) ToParams() []*Param { + ps := make([]*Param, 0) + if len(r.Name) > 0 { + ps = append(ps, &Param{Name: r.Name, Type: r.Type}) + } + if r.ReturnsError { + ps = append(ps, &Param{Name: "err", Type: "error"}) + } + return ps +} + +// List returns source code of syscall return parameters. +func (r *Rets) List() string { + s := join(r.ToParams(), func(p *Param) string { return p.Name + " " + p.Type }, ", ") + if len(s) > 0 { + s = "(" + s + ")" + } + return s +} + +// PrintList returns source code of trace printing part correspondent +// to syscall return values. +func (r *Rets) PrintList() string { + return join(r.ToParams(), func(p *Param) string { return fmt.Sprintf(`"%s=", %s, `, p.Name, p.Name) }, `", ", `) +} + +// SetReturnValuesCode returns source code that accepts syscall return values. +func (r *Rets) SetReturnValuesCode() string { + if r.Name == "" && !r.ReturnsError { + return "" + } + retvar := "r0" + if r.Name == "" { + retvar = "r1" + } + errvar := "_" + if r.ReturnsError { + errvar = "e1" + } + return fmt.Sprintf("%s, _, %s := ", retvar, errvar) +} + +func (r *Rets) useLongHandleErrorCode(retvar string) string { + const code = `if %s { + if e1 != 0 { + err = error(e1) + } else { + err = EINVAL + } + }` + cond := retvar + " == 0" + if r.FailCond != "" { + cond = strings.Replace(r.FailCond, "failretval", retvar, 1) + } + return fmt.Sprintf(code, cond) +} + +// SetErrorCode returns source code that sets return parameters. +func (r *Rets) SetErrorCode() string { + const code = `if r0 != 0 { + %s = Errno(r0) + }` + if r.Name == "" && !r.ReturnsError { + return "" + } + if r.Name == "" { + return r.useLongHandleErrorCode("r1") + } + if r.Type == "error" { + return fmt.Sprintf(code, r.Name) + } + s := "" + if r.Type[0] == '*' { + s = fmt.Sprintf("%s = (%s)(unsafe.Pointer(r0))", r.Name, r.Type) + } else { + s = fmt.Sprintf("%s = %s(r0)", r.Name, r.Type) + } + if !r.ReturnsError { + return s + } + return s + "\n\t" + r.useLongHandleErrorCode(r.Name) +} + +// Fn describes syscall function. +type Fn struct { + Name string + Params []*Param + Rets *Rets + PrintTrace bool + dllname string + dllfuncname string + src string + // TODO: get rid of this field and just use parameter index instead + curTmpVarIdx int // insure tmp variables have uniq names +} + +// extractParams parses s to extract function parameters. +func extractParams(s string, f *Fn) ([]*Param, error) { + s = trim(s) + if s == "" { + return nil, nil + } + a := strings.Split(s, ",") + ps := make([]*Param, len(a)) + for i := range ps { + s2 := trim(a[i]) + b := strings.Split(s2, " ") + if len(b) != 2 { + b = strings.Split(s2, "\t") + if len(b) != 2 { + return nil, errors.New("Could not extract function parameter from \"" + s2 + "\"") + } + } + ps[i] = &Param{ + Name: trim(b[0]), + Type: trim(b[1]), + fn: f, + tmpVarIdx: -1, + } + } + return ps, nil +} + +// extractSection extracts text out of string s starting after start +// and ending just before end. found return value will indicate success, +// and prefix, body and suffix will contain correspondent parts of string s. +func extractSection(s string, start, end rune) (prefix, body, suffix string, found bool) { + s = trim(s) + if strings.HasPrefix(s, string(start)) { + // no prefix + body = s[1:] + } else { + a := strings.SplitN(s, string(start), 2) + if len(a) != 2 { + return "", "", s, false + } + prefix = a[0] + body = a[1] + } + a := strings.SplitN(body, string(end), 2) + if len(a) != 2 { + return "", "", "", false + } + return prefix, a[0], a[1], true +} + +// newFn parses string s and return created function Fn. +func newFn(s string) (*Fn, error) { + s = trim(s) + f := &Fn{ + Rets: &Rets{}, + src: s, + PrintTrace: *PrintTraceFlag, + } + // function name and args + prefix, body, s, found := extractSection(s, '(', ')') + if !found || prefix == "" { + return nil, errors.New("Could not extract function name and parameters from \"" + f.src + "\"") + } + f.Name = prefix + var err error + f.Params, err = extractParams(body, f) + if err != nil { + return nil, err + } + // return values + _, body, s, found = extractSection(s, '(', ')') + if found { + r, err := extractParams(body, f) + if err != nil { + return nil, err + } + switch len(r) { + case 0: + case 1: + if r[0].IsError() { + f.Rets.ReturnsError = true + } else { + f.Rets.Name = r[0].Name + f.Rets.Type = r[0].Type + } + case 2: + if !r[1].IsError() { + return nil, errors.New("Only last windows error is allowed as second return value in \"" + f.src + "\"") + } + f.Rets.ReturnsError = true + f.Rets.Name = r[0].Name + f.Rets.Type = r[0].Type + default: + return nil, errors.New("Too many return values in \"" + f.src + "\"") + } + } + // fail condition + _, body, s, found = extractSection(s, '[', ']') + if found { + f.Rets.FailCond = body + } + // dll and dll function names + s = trim(s) + if s == "" { + return f, nil + } + if !strings.HasPrefix(s, "=") { + return nil, errors.New("Could not extract dll name from \"" + f.src + "\"") + } + s = trim(s[1:]) + a := strings.Split(s, ".") + switch len(a) { + case 1: + f.dllfuncname = a[0] + case 2: + f.dllname = a[0] + f.dllfuncname = a[1] + default: + return nil, errors.New("Could not extract dll name from \"" + f.src + "\"") + } + return f, nil +} + +// DLLName returns DLL name for function f. +func (f *Fn) DLLName() string { + if f.dllname == "" { + return "kernel32" + } + return f.dllname +} + +// DLLName returns DLL function name for function f. +func (f *Fn) DLLFuncName() string { + if f.dllfuncname == "" { + return f.Name + } + return f.dllfuncname +} + +// ParamList returns source code for function f parameters. +func (f *Fn) ParamList() string { + return join(f.Params, func(p *Param) string { return p.Name + " " + p.Type }, ", ") +} + +// ParamPrintList returns source code of trace printing part correspondent +// to syscall input parameters. +func (f *Fn) ParamPrintList() string { + return join(f.Params, func(p *Param) string { return fmt.Sprintf(`"%s=", %s, `, p.Name, p.Name) }, `", ", `) +} + +// ParamCount return number of syscall parameters for function f. +func (f *Fn) ParamCount() int { + n := 0 + for _, p := range f.Params { + n += len(p.SyscallArgList()) + } + return n +} + +// SyscallParamCount determines which version of Syscall/Syscall6/Syscall9/... +// to use. It returns parameter count for correspondent SyscallX function. +func (f *Fn) SyscallParamCount() int { + n := f.ParamCount() + switch { + case n <= 3: + return 3 + case n <= 6: + return 6 + case n <= 9: + return 9 + case n <= 12: + return 12 + case n <= 15: + return 15 + default: + panic("too many arguments to system call") + } +} + +// Syscall determines which SyscallX function to use for function f. +func (f *Fn) Syscall() string { + c := f.SyscallParamCount() + if c == 3 { + return "Syscall" + } + return "Syscall" + strconv.Itoa(c) +} + +// SyscallParamList returns source code for SyscallX parameters for function f. +func (f *Fn) SyscallParamList() string { + a := make([]string, 0) + for _, p := range f.Params { + a = append(a, p.SyscallArgList()...) + } + for len(a) < f.SyscallParamCount() { + a = append(a, "0") + } + return strings.Join(a, ", ") +} + +// IsUTF16 is true, if f is W (utf16) function. It is false +// for all A (ascii) functions. +func (f *Fn) IsUTF16() bool { + s := f.DLLFuncName() + return s[len(s)-1] == 'W' +} + +// StrconvFunc returns name of Go string to OS string function for f. +func (f *Fn) StrconvFunc() string { + if f.IsUTF16() { + return "UTF16PtrFromString" + } + return "BytePtrFromString" +} + +// StrconvType returns Go type name used for OS string for f. +func (f *Fn) StrconvType() string { + if f.IsUTF16() { + return "*uint16" + } + return "*byte" +} + +// Source files and functions. +type Source struct { + Funcs []*Fn + Files []string +} + +// ParseFiles parses files listed in fs and extracts all syscall +// functions listed in sys comments. It returns source files +// and functions collection *Source if successful. +func ParseFiles(fs []string) (*Source, error) { + src := &Source{ + Funcs: make([]*Fn, 0), + Files: make([]string, 0), + } + for _, file := range fs { + if err := src.ParseFile(file); err != nil { + return nil, err + } + } + return src, nil +} + +// DLLs return dll names for a source set src. +func (src *Source) DLLs() []string { + uniq := make(map[string]bool) + r := make([]string, 0) + for _, f := range src.Funcs { + name := f.DLLName() + if _, found := uniq[name]; !found { + uniq[name] = true + r = append(r, name) + } + } + return r +} + +// ParseFile adds adition file path to a source set src. +func (src *Source) ParseFile(path string) error { + file, err := os.Open(path) + if err != nil { + return err + } + defer file.Close() + + s := bufio.NewScanner(file) + for s.Scan() { + t := trim(s.Text()) + if len(t) < 7 { + continue + } + if !strings.HasPrefix(t, "//sys") { + continue + } + t = t[5:] + if !(t[0] == ' ' || t[0] == '\t') { + continue + } + f, err := newFn(t[1:]) + if err != nil { + return err + } + src.Funcs = append(src.Funcs, f) + } + if err := s.Err(); err != nil { + return err + } + src.Files = append(src.Files, path) + return nil +} + +// Generate output source file from a source set src. +func (src *Source) Generate(w io.Writer) error { + t := template.Must(template.New("main").Parse(srcTemplate)) + err := t.Execute(w, src) + if err != nil { + return errors.New("Failed to execute template: " + err.Error()) + } + return nil +} + +func usage() { + fmt.Fprintf(os.Stderr, "usage: mksyscall_windows [flags] [path ...]\n") + flag.PrintDefaults() + os.Exit(1) +} + +func main() { + flag.Usage = usage + flag.Parse() + if len(os.Args) <= 1 { + fmt.Fprintf(os.Stderr, "no files to parse provided\n") + usage() + } + src, err := ParseFiles(os.Args[1:]) + if err != nil { + log.Fatal(err) + } + if err := src.Generate(os.Stdout); err != nil { + log.Fatal(err) + } +} + +// TODO: use println instead to print in the following template +const srcTemplate = ` + +{{define "main"}}// go build mksyscall_windows.go && ./mksyscall_windows{{range .Files}} {{.}}{{end}} +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +package syscall + +import "unsafe" + +var ( +{{template "dlls" .}} +{{template "funcnames" .}}) +{{range .Funcs}}{{template "funcbody" .}}{{end}} +{{end}} + +{{/* help functions */}} + +{{define "dlls"}}{{range .DLLs}} mod{{.}} = NewLazyDLL("{{.}}.dll") +{{end}}{{end}} + +{{define "funcnames"}}{{range .Funcs}} proc{{.DLLFuncName}} = mod{{.DLLName}}.NewProc("{{.DLLFuncName}}") +{{end}}{{end}} + +{{define "funcbody"}} +func {{.Name}}({{.ParamList}}) {{if .Rets.List}}{{.Rets.List}} {{end}}{ +{{template "tmpvars" .}} {{template "syscall" .}} +{{template "seterror" .}}{{template "printtrace" .}} return +} +{{end}} + +{{define "tmpvars"}}{{range .Params}}{{if .TmpVarCode}} {{.TmpVarCode}} +{{end}}{{end}}{{end}} + +{{define "syscall"}}{{.Rets.SetReturnValuesCode}}{{.Syscall}}(proc{{.DLLFuncName}}.Addr(), {{.ParamCount}}, {{.SyscallParamList}}){{end}} + +{{define "seterror"}}{{if .Rets.SetErrorCode}} {{.Rets.SetErrorCode}} +{{end}}{{end}} + +{{define "printtrace"}}{{if .PrintTrace}} print("SYSCALL: {{.Name}}(", {{.ParamPrintList}}") (", {{.Rets.PrintList}}")\n") +{{end}}{{end}} + +` diff --git a/src/pkg/syscall/mksysnum_dragonfly.pl b/src/pkg/syscall/mksysnum_dragonfly.pl index 769c29ea7..3eba3ab3d 100755 --- a/src/pkg/syscall/mksysnum_dragonfly.pl +++ b/src/pkg/syscall/mksysnum_dragonfly.pl @@ -20,7 +20,7 @@ const ( EOF while(<>){ - if(/^([0-9]+)\s+STD\s+\S+\s+({ \S+\s+(\w+).*)$/){ + if(/^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$/){ my $num = $1; my $proto = $2; my $name = "SYS_$3"; diff --git a/src/pkg/syscall/mksysnum_freebsd.pl b/src/pkg/syscall/mksysnum_freebsd.pl index 5c156338e..cd675780b 100755 --- a/src/pkg/syscall/mksysnum_freebsd.pl +++ b/src/pkg/syscall/mksysnum_freebsd.pl @@ -33,8 +33,21 @@ while(<>){ if($name eq 'SYS_SYS_EXIT'){ $name = 'SYS_EXIT'; } + if($name =~ /^SYS_CAP_+/ || $name =~ /^SYS___CAP_+/){ + next + } print " $name = $num; // $proto\n"; + + # We keep Capsicum syscall numbers for FreeBSD + # 9-STABLE here because we are not sure whether they + # are mature and stable. + if($num == 513){ + print " SYS_CAP_NEW = 514 // { int cap_new(int fd, uint64_t rights); }\n"; + print " SYS_CAP_GETRIGHTS = 515 // { int cap_getrights(int fd, \\\n"; + print " SYS_CAP_ENTER = 516 // { int cap_enter(void); }\n"; + print " SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); }\n"; + } } } diff --git a/src/pkg/syscall/mmap_unix_test.go b/src/pkg/syscall/mmap_unix_test.go new file mode 100644 index 000000000..01f778302 --- /dev/null +++ b/src/pkg/syscall/mmap_unix_test.go @@ -0,0 +1,22 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build darwin dragonfly freebsd linux netbsd openbsd + +package syscall_test + +import ( + "syscall" + "testing" +) + +func TestMmap(t *testing.T) { + b, err := syscall.Mmap(-1, 0, syscall.Getpagesize(), syscall.PROT_NONE, syscall.MAP_ANON|syscall.MAP_PRIVATE) + if err != nil { + t.Fatalf("Mmap: %v", err) + } + if err := syscall.Munmap(b); err != nil { + t.Fatalf("Munmap: %v", err) + } +} diff --git a/src/pkg/syscall/net_nacl.go b/src/pkg/syscall/net_nacl.go new file mode 100644 index 000000000..b9488f48d --- /dev/null +++ b/src/pkg/syscall/net_nacl.go @@ -0,0 +1,912 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// A simulated network for use within NaCl. +// The simulation is not particularly tied to NaCl, +// but other systems have real networks. + +package syscall + +import ( + "sync" + "sync/atomic" +) + +// Interface to timers implemented in package runtime. +// Must be in sync with ../runtime/runtime.h:/^struct.Timer$ +// Really for use by package time, but we cannot import time here. + +type runtimeTimer struct { + i int32 + when int64 + period int64 + f func(int64, interface{}) // NOTE: must not be closure + arg interface{} +} + +func startTimer(*runtimeTimer) +func stopTimer(*runtimeTimer) bool + +type timer struct { + expired bool + q *queue + r runtimeTimer +} + +func (t *timer) start(q *queue, deadline int64) { + if deadline == 0 { + return + } + t.q = q + t.r.when = deadline + t.r.f = timerExpired + t.r.arg = t + startTimer(&t.r) +} + +func (t *timer) stop() { + stopTimer(&t.r) +} + +func timerExpired(now int64, i interface{}) { + t := i.(*timer) + go func() { + t.q.Lock() + defer t.q.Unlock() + t.expired = true + t.q.canRead.Broadcast() + t.q.canWrite.Broadcast() + }() +} + +// Network constants and data structures. These match the traditional values. + +const ( + AF_UNSPEC = iota + AF_UNIX + AF_INET + AF_INET6 +) + +const ( + SHUT_RD = iota + SHUT_WR + SHUT_RDWR +) + +const ( + SOCK_STREAM = 1 + iota + SOCK_DGRAM + SOCK_RAW + SOCK_SEQPACKET +) + +const ( + IPPROTO_IP = 0 + IPPROTO_IPV4 = 4 + IPPROTO_IPV6 = 0x29 + IPPROTO_TCP = 6 + IPPROTO_UDP = 0x11 +) + +// Misc constants expected by package net but not supported. +const ( + _ = iota + SOL_SOCKET + SO_TYPE + NET_RT_IFLIST + IFNAMSIZ + IFF_UP + IFF_BROADCAST + IFF_LOOPBACK + IFF_POINTOPOINT + IFF_MULTICAST + IPV6_V6ONLY + SOMAXCONN + F_DUPFD_CLOEXEC + SO_BROADCAST + SO_REUSEADDR + SO_REUSEPORT + SO_RCVBUF + SO_SNDBUF + SO_KEEPALIVE + SO_LINGER + SO_ERROR + IP_PORTRANGE + IP_PORTRANGE_DEFAULT + IP_PORTRANGE_LOW + IP_PORTRANGE_HIGH + IP_MULTICAST_IF + IP_MULTICAST_LOOP + IP_ADD_MEMBERSHIP + IPV6_PORTRANGE + IPV6_PORTRANGE_DEFAULT + IPV6_PORTRANGE_LOW + IPV6_PORTRANGE_HIGH + IPV6_MULTICAST_IF + IPV6_MULTICAST_LOOP + IPV6_JOIN_GROUP + TCP_NODELAY + TCP_KEEPINTVL + TCP_KEEPIDLE + + SYS_FCNTL = 500 // unsupported +) + +var SocketDisableIPv6 bool + +// A Sockaddr is one of the SockaddrXxx structs. +type Sockaddr interface { + // copy returns a copy of the underlying data. + copy() Sockaddr + + // key returns the value of the underlying data, + // for comparison as a map key. + key() interface{} +} + +type SockaddrInet4 struct { + Port int + Addr [4]byte +} + +func (sa *SockaddrInet4) copy() Sockaddr { + sa1 := *sa + return &sa1 +} + +func (sa *SockaddrInet4) key() interface{} { return *sa } + +type SockaddrInet6 struct { + Port int + ZoneId uint32 + Addr [16]byte +} + +func (sa *SockaddrInet6) copy() Sockaddr { + sa1 := *sa + return &sa1 +} + +func (sa *SockaddrInet6) key() interface{} { return *sa } + +type SockaddrUnix struct { + Name string +} + +func (sa *SockaddrUnix) copy() Sockaddr { + sa1 := *sa + return &sa1 +} + +func (sa *SockaddrUnix) key() interface{} { return *sa } + +type SockaddrDatalink struct { + Len uint8 + Family uint8 + Index uint16 + Type uint8 + Nlen uint8 + Alen uint8 + Slen uint8 + Data [12]int8 +} + +func (sa *SockaddrDatalink) copy() Sockaddr { + sa1 := *sa + return &sa1 +} + +func (sa *SockaddrDatalink) key() interface{} { return *sa } + +// RoutingMessage represents a routing message. +type RoutingMessage interface { + unimplemented() +} + +type IPMreq struct { + Multiaddr [4]byte /* in_addr */ + Interface [4]byte /* in_addr */ +} + +type IPv6Mreq struct { + Multiaddr [16]byte /* in6_addr */ + Interface uint32 +} + +type Linger struct { + Onoff int32 + Linger int32 +} + +type ICMPv6Filter struct { + Filt [8]uint32 +} + +// A queue is the bookkeeping for a synchronized buffered queue. +// We do not use channels because we need to be able to handle +// writes after and during close, and because a chan byte would +// require too many send and receive operations in real use. +type queue struct { + sync.Mutex + canRead sync.Cond + canWrite sync.Cond + r int // total read index + w int // total write index + m int // index mask + closed bool +} + +func (q *queue) init(size int) { + if size&(size-1) != 0 { + panic("invalid queue size - must be power of two") + } + q.canRead.L = &q.Mutex + q.canWrite.L = &q.Mutex + q.m = size - 1 +} + +func past(deadline int64) bool { + sec, nsec := now() + return deadline > 0 && deadline < sec*1e9+int64(nsec) +} + +func (q *queue) waitRead(n int, deadline int64) (int, error) { + if past(deadline) { + return 0, EAGAIN + } + var t timer + t.start(q, deadline) + for q.w-q.r == 0 && !q.closed && !t.expired { + q.canRead.Wait() + } + t.stop() + m := q.w - q.r + if m == 0 && t.expired { + return 0, EAGAIN + } + if m > n { + m = n + q.canRead.Signal() // wake up next reader too + } + q.canWrite.Signal() + return m, nil +} + +func (q *queue) waitWrite(n int, deadline int64) (int, error) { + if past(deadline) { + return 0, EAGAIN + } + var t timer + t.start(q, deadline) + for q.w-q.r > q.m && !q.closed && !t.expired { + q.canWrite.Wait() + } + t.stop() + m := q.m + 1 - (q.w - q.r) + if m == 0 && t.expired { + return 0, EAGAIN + } + if m == 0 { + return 0, EAGAIN + } + if m > n { + m = n + q.canWrite.Signal() // wake up next writer too + } + q.canRead.Signal() + return m, nil +} + +func (q *queue) close() { + q.Lock() + defer q.Unlock() + q.closed = true + q.canRead.Broadcast() + q.canWrite.Broadcast() +} + +// A byteq is a byte queue. +type byteq struct { + queue + data []byte +} + +func newByteq() *byteq { + q := &byteq{ + data: make([]byte, 4096), + } + q.init(len(q.data)) + return q +} + +func (q *byteq) read(b []byte, deadline int64) (int, error) { + q.Lock() + defer q.Unlock() + n, err := q.waitRead(len(b), deadline) + if err != nil { + return 0, err + } + b = b[:n] + for len(b) > 0 { + m := copy(b, q.data[q.r&q.m:]) + q.r += m + b = b[m:] + } + return n, nil +} + +func (q *byteq) write(b []byte, deadline int64) (n int, err error) { + q.Lock() + defer q.Unlock() + for n < len(b) { + nn, err := q.waitWrite(len(b[n:]), deadline) + if err != nil { + return n, err + } + bb := b[n : n+nn] + n += nn + for len(bb) > 0 { + m := copy(q.data[q.w&q.m:], bb) + q.w += m + bb = bb[m:] + } + } + return n, nil +} + +// A msgq is a queue of messages. +type msgq struct { + queue + data []interface{} +} + +func newMsgq() *msgq { + q := &msgq{ + data: make([]interface{}, 32), + } + q.init(len(q.data)) + return q +} + +func (q *msgq) read(deadline int64) (interface{}, error) { + q.Lock() + defer q.Unlock() + n, err := q.waitRead(1, deadline) + if err != nil { + return nil, err + } + if n == 0 { + return nil, nil + } + m := q.data[q.r&q.m] + q.r++ + return m, nil +} + +func (q *msgq) write(m interface{}, deadline int64) error { + q.Lock() + defer q.Unlock() + _, err := q.waitWrite(1, deadline) + if err != nil { + return err + } + q.data[q.w&q.m] = m + q.w++ + return nil +} + +// An addr is a sequence of bytes uniquely identifying a network address. +// It is not human-readable. +type addr string + +// A conn is one side of a stream-based network connection. +// That is, a stream-based network connection is a pair of cross-connected conns. +type conn struct { + rd *byteq + wr *byteq + local addr + remote addr +} + +// A pktconn is one side of a packet-based network connection. +// That is, a packet-based network connection is a pair of cross-connected pktconns. +type pktconn struct { + rd *msgq + wr *msgq + local addr + remote addr +} + +// A listener accepts incoming stream-based network connections. +type listener struct { + rd *msgq + local addr +} + +// A netFile is an open network file. +type netFile struct { + defaultFileImpl + proto *netproto + sotype int + listener *msgq + packet *msgq + rd *byteq + wr *byteq + rddeadline int64 + wrdeadline int64 + addr Sockaddr + raddr Sockaddr +} + +// A netAddr is a network address in the global listener map. +// All the fields must have defined == operations. +type netAddr struct { + proto *netproto + sotype int + addr interface{} +} + +// net records the state of the network. +// It maps a network address to the listener on that address. +var net = struct { + sync.Mutex + listener map[netAddr]*netFile +}{ + listener: make(map[netAddr]*netFile), +} + +// TODO(rsc): Some day, do a better job with port allocation. +// For playground programs, incrementing is fine. +var nextport = 2 + +// A netproto contains protocol-specific functionality +// (one for AF_INET, one for AF_INET6 and so on). +// It is a struct instead of an interface because the +// implementation needs no state, and I expect to +// add some data fields at some point. +type netproto struct { + bind func(*netFile, Sockaddr) error +} + +var netprotoAF_INET = &netproto{ + bind: func(f *netFile, sa Sockaddr) error { + if sa == nil { + f.addr = &SockaddrInet4{ + Port: nextport, + Addr: [4]byte{127, 0, 0, 1}, + } + nextport++ + return nil + } + addr, ok := sa.(*SockaddrInet4) + if !ok { + return EINVAL + } + addr = addr.copy().(*SockaddrInet4) + if addr.Port == 0 { + addr.Port = nextport + nextport++ + } + f.addr = addr + return nil + }, +} + +var netprotos = map[int]*netproto{ + AF_INET: netprotoAF_INET, +} + +// These functions implement the usual BSD socket operations. + +func (f *netFile) bind(sa Sockaddr) error { + if f.addr != nil { + return EISCONN + } + if err := f.proto.bind(f, sa); err != nil { + return err + } + if f.sotype == SOCK_DGRAM { + _, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] + if ok { + f.addr = nil + return EADDRINUSE + } + net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f + f.packet = newMsgq() + } + return nil +} + +func (f *netFile) listen(backlog int) error { + net.Lock() + defer net.Unlock() + if f.listener != nil { + return EINVAL + } + _, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] + if ok { + return EADDRINUSE + } + net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f + f.listener = newMsgq() + return nil +} + +func (f *netFile) accept() (fd int, sa Sockaddr, err error) { + msg, err := f.listener.read(f.readDeadline()) + if err != nil { + return -1, nil, err + } + newf, ok := msg.(*netFile) + if !ok { + // must be eof + return -1, nil, EAGAIN + } + return newFD(newf), newf.raddr.copy(), nil +} + +func (f *netFile) connect(sa Sockaddr) error { + if past(f.writeDeadline()) { + return EAGAIN + } + if f.addr == nil { + if err := f.bind(nil); err != nil { + return err + } + } + net.Lock() + if sa == nil { + net.Unlock() + return EINVAL + } + sa = sa.copy() + if f.raddr != nil { + net.Unlock() + return EISCONN + } + if f.sotype == SOCK_DGRAM { + net.Unlock() + f.raddr = sa + return nil + } + if f.listener != nil { + net.Unlock() + return EISCONN + } + l, ok := net.listener[netAddr{f.proto, f.sotype, sa.key()}] + if !ok { + net.Unlock() + return ECONNREFUSED + } + f.raddr = sa + f.rd = newByteq() + f.wr = newByteq() + newf := &netFile{ + proto: f.proto, + sotype: f.sotype, + addr: f.raddr, + raddr: f.addr, + rd: f.wr, + wr: f.rd, + } + net.Unlock() + l.listener.write(newf, f.writeDeadline()) + return nil +} + +func (f *netFile) read(b []byte) (int, error) { + if f.rd == nil { + if f.raddr != nil { + n, _, err := f.recvfrom(b, 0) + return n, err + } + return 0, ENOTCONN + } + return f.rd.read(b, f.readDeadline()) +} + +func (f *netFile) write(b []byte) (int, error) { + if f.wr == nil { + if f.raddr != nil { + err := f.sendto(b, 0, f.raddr) + var n int + if err == nil { + n = len(b) + } + return n, err + } + return 0, ENOTCONN + } + return f.wr.write(b, f.writeDeadline()) +} + +type pktmsg struct { + buf []byte + addr Sockaddr +} + +func (f *netFile) recvfrom(p []byte, flags int) (n int, from Sockaddr, err error) { + if f.sotype != SOCK_DGRAM { + return 0, nil, EINVAL + } + if f.packet == nil { + return 0, nil, ENOTCONN + } + msg1, err := f.packet.read(f.readDeadline()) + if err != nil { + return 0, nil, err + } + msg, ok := msg1.(*pktmsg) + if !ok { + return 0, nil, EAGAIN + } + return copy(p, msg.buf), msg.addr, nil +} + +func (f *netFile) sendto(p []byte, flags int, to Sockaddr) error { + if f.sotype != SOCK_DGRAM { + return EINVAL + } + if f.packet == nil { + if err := f.bind(nil); err != nil { + return err + } + } + net.Lock() + if to == nil { + net.Unlock() + return EINVAL + } + to = to.copy() + l, ok := net.listener[netAddr{f.proto, f.sotype, to.key()}] + if !ok || l.packet == nil { + net.Unlock() + return ECONNREFUSED + } + net.Unlock() + msg := &pktmsg{ + buf: make([]byte, len(p)), + addr: f.addr, + } + copy(msg.buf, p) + l.packet.write(msg, f.writeDeadline()) + return nil +} + +func (f *netFile) close() error { + if f.listener != nil { + f.listener.close() + } + if f.packet != nil { + f.packet.close() + } + if f.rd != nil { + f.rd.close() + } + if f.wr != nil { + f.wr.close() + } + return nil +} + +func fdToNetFile(fd int) (*netFile, error) { + f, err := fdToFile(fd) + if err != nil { + return nil, err + } + impl := f.impl + netf, ok := impl.(*netFile) + if !ok { + return nil, EINVAL + } + return netf, nil +} + +func Socket(proto, sotype, unused int) (fd int, err error) { + p := netprotos[proto] + if p == nil { + return -1, EPROTONOSUPPORT + } + if sotype != SOCK_STREAM && sotype != SOCK_DGRAM { + return -1, ESOCKTNOSUPPORT + } + f := &netFile{ + proto: p, + sotype: sotype, + } + return newFD(f), nil +} + +func Bind(fd int, sa Sockaddr) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + return f.bind(sa) +} + +func StopIO(fd int) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + f.close() + return nil +} + +func Listen(fd int, backlog int) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + return f.listen(backlog) +} + +func Accept(fd int) (newfd int, sa Sockaddr, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return 0, nil, err + } + return f.accept() +} + +func Getsockname(fd int) (sa Sockaddr, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return nil, err + } + if f.addr == nil { + return nil, ENOTCONN + } + return f.addr.copy(), nil +} + +func Getpeername(fd int) (sa Sockaddr, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return nil, err + } + if f.raddr == nil { + return nil, ENOTCONN + } + return f.raddr.copy(), nil +} + +func Connect(fd int, sa Sockaddr) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + return f.connect(sa) +} + +func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return 0, nil, err + } + return f.recvfrom(p, flags) +} + +func Sendto(fd int, p []byte, flags int, to Sockaddr) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + return f.sendto(p, flags, to) +} + +func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn, recvflags int, from Sockaddr, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return + } + n, from, err = f.recvfrom(p, flags) + return +} + +func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) error { + _, err := SendmsgN(fd, p, oob, to, flags) + return err +} + +func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return 0, err + } + switch f.sotype { + case SOCK_STREAM: + n, err = f.write(p) + case SOCK_DGRAM: + n = len(p) + err = f.sendto(p, flags, to) + } + if err != nil { + return 0, err + } + return n, nil +} + +func GetsockoptInt(fd, level, opt int) (value int, err error) { + f, err := fdToNetFile(fd) + if err != nil { + return 0, err + } + switch { + case level == SOL_SOCKET && opt == SO_TYPE: + return f.sotype, nil + } + return 0, ENOTSUP +} + +func SetsockoptInt(fd, level, opt int, value int) error { + return nil +} + +func SetsockoptByte(fd, level, opt int, value byte) error { + _, err := fdToNetFile(fd) + if err != nil { + return err + } + return ENOTSUP +} + +func SetsockoptLinger(fd, level, opt int, l *Linger) error { + return nil +} + +func SetReadDeadline(fd int, t int64) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + atomic.StoreInt64(&f.rddeadline, t) + return nil +} + +func (f *netFile) readDeadline() int64 { + return atomic.LoadInt64(&f.rddeadline) +} + +func SetWriteDeadline(fd int, t int64) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + atomic.StoreInt64(&f.wrdeadline, t) + return nil +} + +func (f *netFile) writeDeadline() int64 { + return atomic.LoadInt64(&f.wrdeadline) +} + +func Shutdown(fd int, how int) error { + f, err := fdToNetFile(fd) + if err != nil { + return err + } + switch how { + case SHUT_RD: + f.rd.close() + case SHUT_WR: + f.wr.close() + case SHUT_RDWR: + f.rd.close() + f.wr.close() + } + return nil +} + +func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { panic("SetsockoptICMPv") } +func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) error { panic("SetsockoptIPMreq") } +func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) error { panic("SetsockoptIPv") } +func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) error { panic("SetsockoptInet") } +func SetsockoptString(fd, level, opt int, s string) error { panic("SetsockoptString") } +func SetsockoptTimeval(fd, level, opt int, tv *Timeval) error { panic("SetsockoptTimeval") } +func Socketpair(domain, typ, proto int) (fd [2]int, err error) { panic("Socketpair") } + +func SetNonblock(fd int, nonblocking bool) error { return nil } diff --git a/src/pkg/syscall/rlimit_linux_test.go b/src/pkg/syscall/rlimit_linux_test.go deleted file mode 100644 index 4ec720e93..000000000 --- a/src/pkg/syscall/rlimit_linux_test.go +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package syscall_test - -import ( - "syscall" - "testing" -) - -func TestRlimit(t *testing.T) { - var rlimit, zero syscall.Rlimit - err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit) - if err != nil { - t.Fatalf("Getrlimit: save failed: %v", err) - } - if zero == rlimit { - t.Fatalf("Getrlimit: save failed: got zero value %#v", rlimit) - } - set := rlimit - set.Cur = set.Max - 1 - err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &set) - if err != nil { - t.Fatalf("Setrlimit: set failed: %#v %v", set, err) - } - var get syscall.Rlimit - err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &get) - if err != nil { - t.Fatalf("Getrlimit: get failed: %v", err) - } - set = rlimit - set.Cur = set.Max - 1 - if set != get { - t.Fatalf("Rlimit: change failed: wanted %#v got %#v", set, get) - } - err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlimit) - if err != nil { - t.Fatalf("Setrlimit: restore failed: %#v %v", rlimit, err) - } -} diff --git a/src/pkg/syscall/route_bsd.go b/src/pkg/syscall/route_bsd.go index 638073592..48af58745 100644 --- a/src/pkg/syscall/route_bsd.go +++ b/src/pkg/syscall/route_bsd.go @@ -199,14 +199,21 @@ func (m *InterfaceAddrMessage) sockaddr() (sas []Sockaddr) { // ParseRoutingMessage parses b as routing messages and returns the // slice containing the RoutingMessage interfaces. func ParseRoutingMessage(b []byte) (msgs []RoutingMessage, err error) { + msgCount := 0 for len(b) >= anyMessageLen { + msgCount++ any := (*anyMessage)(unsafe.Pointer(&b[0])) if any.Version != RTM_VERSION { - return nil, EINVAL + b = b[any.Msglen:] + continue } msgs = append(msgs, any.toRoutingMessage(b)) b = b[any.Msglen:] } + // We failed to parse any of the messages - version mismatch? + if msgCount > 0 && len(msgs) == 0 { + return nil, EINVAL + } return msgs, nil } diff --git a/src/pkg/syscall/route_dragonfly.go b/src/pkg/syscall/route_dragonfly.go index acad7a2be..79190d2b0 100644 --- a/src/pkg/syscall/route_dragonfly.go +++ b/src/pkg/syscall/route_dragonfly.go @@ -30,7 +30,7 @@ func (any *anyMessage) toRoutingMessage(b []byte) RoutingMessage { } // InterfaceAnnounceMessage represents a routing message containing -// network interface arrival and depature information. +// network interface arrival and departure information. type InterfaceAnnounceMessage struct { Header IfAnnounceMsghdr } diff --git a/src/pkg/syscall/route_freebsd.go b/src/pkg/syscall/route_freebsd.go index d8f80316b..15897b1ac 100644 --- a/src/pkg/syscall/route_freebsd.go +++ b/src/pkg/syscall/route_freebsd.go @@ -8,14 +8,20 @@ package syscall import "unsafe" +// See http://www.freebsd.org/doc/en/books/porters-handbook/freebsd-versions.html. +var freebsdVersion uint32 + +func init() { + freebsdVersion, _ = SysctlUint32("kern.osreldate") +} + func (any *anyMessage) toRoutingMessage(b []byte) RoutingMessage { switch any.Type { case RTM_ADD, RTM_DELETE, RTM_CHANGE, RTM_GET, RTM_LOSING, RTM_REDIRECT, RTM_MISS, RTM_LOCK, RTM_RESOLVE: p := (*RouteMessage)(unsafe.Pointer(any)) return &RouteMessage{Header: p.Header, Data: b[SizeofRtMsghdr:any.Msglen]} case RTM_IFINFO: - p := (*InterfaceMessage)(unsafe.Pointer(any)) - return &InterfaceMessage{Header: p.Header, Data: b[SizeofIfMsghdr:any.Msglen]} + return any.parseInterfaceMessage(b) case RTM_IFANNOUNCE: p := (*InterfaceAnnounceMessage)(unsafe.Pointer(any)) return &InterfaceAnnounceMessage{Header: p.Header} @@ -30,7 +36,7 @@ func (any *anyMessage) toRoutingMessage(b []byte) RoutingMessage { } // InterfaceAnnounceMessage represents a routing message containing -// network interface arrival and depature information. +// network interface arrival and departure information. type InterfaceAnnounceMessage struct { Header IfAnnounceMsghdr } diff --git a/src/pkg/syscall/route_freebsd_32bit.go b/src/pkg/syscall/route_freebsd_32bit.go new file mode 100644 index 000000000..93efdddb3 --- /dev/null +++ b/src/pkg/syscall/route_freebsd_32bit.go @@ -0,0 +1,24 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build freebsd,386 freebsd,arm + +package syscall + +import "unsafe" + +func (any *anyMessage) parseInterfaceMessage(b []byte) *InterfaceMessage { + p := (*InterfaceMessage)(unsafe.Pointer(any)) + // FreeBSD 10 and beyond have a restructured mbuf + // packet header view. + // See http://svnweb.freebsd.org/base?view=revision&revision=254804. + if freebsdVersion >= 1000000 { + m := (*ifMsghdr)(unsafe.Pointer(any)) + p.Header.Data.Hwassist = uint32(m.Data.Hwassist) + p.Header.Data.Epoch = m.Data.Epoch + p.Header.Data.Lastchange = m.Data.Lastchange + return &InterfaceMessage{Header: p.Header, Data: b[sizeofIfMsghdr:any.Msglen]} + } + return &InterfaceMessage{Header: p.Header, Data: b[SizeofIfMsghdr:any.Msglen]} +} diff --git a/src/pkg/syscall/route_freebsd_64bit.go b/src/pkg/syscall/route_freebsd_64bit.go new file mode 100644 index 000000000..9377f2fed --- /dev/null +++ b/src/pkg/syscall/route_freebsd_64bit.go @@ -0,0 +1,14 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build freebsd,amd64 + +package syscall + +import "unsafe" + +func (any *anyMessage) parseInterfaceMessage(b []byte) *InterfaceMessage { + p := (*InterfaceMessage)(unsafe.Pointer(any)) + return &InterfaceMessage{Header: p.Header, Data: b[SizeofIfMsghdr:any.Msglen]} +} diff --git a/src/pkg/syscall/route_netbsd.go b/src/pkg/syscall/route_netbsd.go index a6baa02f8..9883aebaf 100644 --- a/src/pkg/syscall/route_netbsd.go +++ b/src/pkg/syscall/route_netbsd.go @@ -27,7 +27,7 @@ func (any *anyMessage) toRoutingMessage(b []byte) RoutingMessage { } // InterfaceAnnounceMessage represents a routing message containing -// network interface arrival and depature information. +// network interface arrival and departure information. type InterfaceAnnounceMessage struct { Header IfAnnounceMsghdr } diff --git a/src/pkg/syscall/route_openbsd.go b/src/pkg/syscall/route_openbsd.go index 223c15779..19f902db7 100644 --- a/src/pkg/syscall/route_openbsd.go +++ b/src/pkg/syscall/route_openbsd.go @@ -27,7 +27,7 @@ func (any *anyMessage) toRoutingMessage(b []byte) RoutingMessage { } // InterfaceAnnounceMessage represents a routing message containing -// network interface arrival and depature information. +// network interface arrival and departure information. type InterfaceAnnounceMessage struct { Header IfAnnounceMsghdr } diff --git a/src/pkg/syscall/so_solaris.go b/src/pkg/syscall/so_solaris.go new file mode 100644 index 000000000..659cd67c1 --- /dev/null +++ b/src/pkg/syscall/so_solaris.go @@ -0,0 +1,260 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +import ( + "sync" + "sync/atomic" + "unsafe" +) + +// soError describes reasons for shared library load failures. +type soError struct { + Err error + ObjName string + Msg string +} + +func (e *soError) Error() string { return e.Msg } + +// Implemented in ../runtime/syscall_solaris.goc. +func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) +func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) +func dlclose(handle uintptr) (err Errno) +func dlopen(name *uint8, mode uintptr) (handle uintptr, err Errno) +func dlsym(handle uintptr, name *uint8) (proc uintptr, err Errno) + +// A so implements access to a single shared library object. +type so struct { + Name string + Handle uintptr +} + +// loadSO loads shared library file into memory. +func loadSO(name string) (*so, error) { + namep, err := BytePtrFromString(name) + if err != nil { + return nil, err + } + h, e := dlopen(namep, 1) // RTLD_LAZY + if e != 0 { + return nil, &soError{ + Err: e, + ObjName: name, + Msg: "Failed to load " + name + ": " + e.Error(), + } + } + d := &so{ + Name: name, + Handle: uintptr(h), + } + return d, nil +} + +// mustLoadSO is like loadSO but panics if load operation fails. +func mustLoadSO(name string) *so { + d, e := loadSO(name) + if e != nil { + panic(e) + } + return d +} + +// FindProc searches shared library d for procedure named name and returns +// *proc if found. It returns an error if the search fails. +func (d *so) FindProc(name string) (*proc, error) { + namep, err := BytePtrFromString(name) + if err != nil { + return nil, err + } + a, _ := dlsym(uintptr(d.Handle), namep) + if a == 0 { + return nil, &soError{ + Err: ENOSYS, + ObjName: name, + Msg: "Failed to find " + name + " procedure in " + d.Name, + } + } + p := &proc{ + SO: d, + Name: name, + addr: a, + } + return p, nil +} + +// MustFindProc is like FindProc but panics if search fails. +func (d *so) MustFindProc(name string) *proc { + p, e := d.FindProc(name) + if e != nil { + panic(e) + } + return p +} + +// Release unloads shared library d from memory. +func (d *so) Release() (err error) { + return dlclose(d.Handle) +} + +// A proc implements access to a procedure inside a shared library. +type proc struct { + SO *so + Name string + addr uintptr +} + +// Addr returns the address of the procedure represented by p. +// The return value can be passed to Syscall to run the procedure. +func (p *proc) Addr() uintptr { + return p.addr +} + +// Call executes procedure p with arguments a. It will panic, if more then +// 6 arguments are supplied. +// +// The returned error is always non-nil, constructed from the result of +// GetLastError. Callers must inspect the primary return value to decide +// whether an error occurred (according to the semantics of the specific +// function being called) before consulting the error. The error will be +// guaranteed to contain syscall.Errno. +func (p *proc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) { + switch len(a) { + case 0: + return sysvicall6(p.Addr(), uintptr(len(a)), 0, 0, 0, 0, 0, 0) + case 1: + return sysvicall6(p.Addr(), uintptr(len(a)), a[0], 0, 0, 0, 0, 0) + case 2: + return sysvicall6(p.Addr(), uintptr(len(a)), a[0], a[1], 0, 0, 0, 0) + case 3: + return sysvicall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], 0, 0, 0) + case 4: + return sysvicall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], 0, 0) + case 5: + return sysvicall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], 0) + case 6: + return sysvicall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5]) + default: + panic("Call " + p.Name + " with too many arguments " + itoa(len(a)) + ".") + } + return +} + +// A lazySO implements access to a single shared library. It will delay +// the load of the shared library until the first call to its Handle method +// or to one of its lazyProc's Addr method. +type lazySO struct { + mu sync.Mutex + so *so // non nil once SO is loaded + Name string +} + +// Load loads single shared file d.Name into memory. It returns an error if +// fails. Load will not try to load SO, if it is already loaded into memory. +func (d *lazySO) Load() error { + // Non-racy version of: + // if d.so == nil { + if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&d.so))) == nil { + d.mu.Lock() + defer d.mu.Unlock() + if d.so == nil { + so, e := loadSO(d.Name) + if e != nil { + return e + } + // Non-racy version of: + // d.so = so + atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&d.so)), unsafe.Pointer(so)) + } + } + return nil +} + +// mustLoad is like Load but panics if search fails. +func (d *lazySO) mustLoad() { + e := d.Load() + if e != nil { + panic(e) + } +} + +// Handle returns d's module handle. +func (d *lazySO) Handle() uintptr { + d.mustLoad() + return uintptr(d.so.Handle) +} + +// NewProc returns a lazyProc for accessing the named procedure in the SO d. +func (d *lazySO) NewProc(name string) *lazyProc { + return &lazyProc{l: d, Name: name} +} + +// newLazySO creates new lazySO associated with SO file. +func newLazySO(name string) *lazySO { + return &lazySO{Name: name} +} + +// A lazyProc implements access to a procedure inside a lazySO. +// It delays the lookup until the Addr method is called. +type lazyProc struct { + mu sync.Mutex + Name string + l *lazySO + proc *proc +} + +// Find searches the shared library for procedure named p.Name. It returns an +// error if search fails. Find will not search procedure, if it is already +// found and loaded into memory. +func (p *lazyProc) Find() error { + // Non-racy version of: + // if p.proc == nil { + if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc))) == nil { + p.mu.Lock() + defer p.mu.Unlock() + if p.proc == nil { + e := p.l.Load() + if e != nil { + return e + } + proc, e := p.l.so.FindProc(p.Name) + if e != nil { + return e + } + // Non-racy version of: + // p.proc = proc + atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc)), unsafe.Pointer(proc)) + } + } + return nil +} + +// mustFind is like Find but panics if search fails. +func (p *lazyProc) mustFind() { + e := p.Find() + if e != nil { + panic(e) + } +} + +// Addr returns the address of the procedure represented by p. +// The return value can be passed to Syscall to run the procedure. +func (p *lazyProc) Addr() uintptr { + p.mustFind() + return p.proc.Addr() +} + +// Call executes procedure p with arguments a. It will panic, if more then +// 6 arguments are supplied. +// +// The returned error is always non-nil, constructed from the result of +// GetLastError. Callers must inspect the primary return value to decide +// whether an error occurred (according to the semantics of the specific +// function being called) before consulting the error. The error will be +// guaranteed to contain syscall.Errno. +func (p *lazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) { + p.mustFind() + return p.proc.Call(a...) +} diff --git a/src/pkg/syscall/sockcmsg_unix.go b/src/pkg/syscall/sockcmsg_unix.go index a2d234f21..045a012c0 100644 --- a/src/pkg/syscall/sockcmsg_unix.go +++ b/src/pkg/syscall/sockcmsg_unix.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build darwin dragonfly freebsd linux netbsd openbsd +// +build darwin dragonfly freebsd linux netbsd openbsd solaris // Socket control messages @@ -13,9 +13,9 @@ import "unsafe" // Round the length of a raw sockaddr up to align it properly. func cmsgAlignOf(salen int) int { salign := sizeofPtr - // NOTE: It seems like 64-bit Darwin kernel still requires 32-bit - // aligned access to BSD subsystem. - if darwin64Bit { + // NOTE: It seems like 64-bit Darwin and DragonFly BSD kernels + // still require 32-bit aligned access to network subsystem. + if darwin64Bit || dragonfly64Bit { salign = 4 } return (salen + salign - 1) & ^(salign - 1) diff --git a/src/pkg/syscall/srpc_nacl.go b/src/pkg/syscall/srpc_nacl.go new file mode 100644 index 000000000..dd07373d1 --- /dev/null +++ b/src/pkg/syscall/srpc_nacl.go @@ -0,0 +1,822 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Native Client SRPC message passing. +// This code is needed to invoke SecureRandom, the NaCl equivalent of /dev/random. + +package syscall + +import ( + "errors" + "sync" + "unsafe" +) + +// An srpcClient represents the client side of an SRPC connection. +type srpcClient struct { + fd int // to server + r msgReceiver + s msgSender + service map[string]srpcService // services by name + + outMu sync.Mutex // protects writing to connection + + mu sync.Mutex // protects following fields + muxer bool // is someone reading and muxing responses + pending map[uint32]*srpc + idGen uint32 // generator for request IDs +} + +// An srpcService is a single method that the server offers. +type srpcService struct { + num uint32 // method number + fmt string // argument format; see "parsing of RPC messages" below +} + +// An srpc represents a single srpc issued by a client. +type srpc struct { + Ret []interface{} + Done chan *srpc + Err error + c *srpcClient + id uint32 +} + +// newClient allocates a new SRPC client using the file descriptor fd. +func newClient(fd int) (*srpcClient, error) { + c := new(srpcClient) + c.fd = fd + c.r.fd = fd + c.s.fd = fd + c.service = make(map[string]srpcService) + c.pending = make(map[uint32]*srpc) + + // service discovery request + m := &msg{ + isRequest: 1, + template: []interface{}{[]byte(nil)}, + size: []int{4000}, // max size to accept for returned byte slice + } + if err := m.pack(); err != nil { + return nil, errors.New("Native Client SRPC service_discovery: preparing request: " + err.Error()) + } + c.s.send(m) + m, err := c.r.recv() + if err != nil { + return nil, err + } + m.unpack() + if m.status != uint32(srpcOK) { + return nil, errors.New("Native Client SRPC service_discovery: " + srpcErrno(m.status).Error()) + } + list := m.value[0].([]byte) + var n uint32 + for len(list) > 0 { + var line []byte + i := byteIndex(list, '\n') + if i < 0 { + line, list = list, nil + } else { + line, list = list[:i], list[i+1:] + } + i = byteIndex(line, ':') + if i >= 0 { + c.service[string(line)] = srpcService{n, string(line[i+1:])} + } + n++ + } + + return c, nil +} + +func byteIndex(b []byte, c byte) int { + for i, bi := range b { + if bi == c { + return i + } + } + return -1 +} + +var yourTurn srpc + +func (c *srpcClient) wait(r *srpc) { + var rx *srpc + for rx = range r.Done { + if rx != &yourTurn { + break + } + c.input() + } + return +} + +func (c *srpcClient) input() { + // read message + m, err := c.r.recv() + if err != nil { + println("Native Client SRPC receive error:", err.Error()) + return + } + if m.unpack(); m.status != uint32(srpcOK) { + println("Native Client SRPC receive error: invalid message: ", srpcErrno(m.status).Error()) + return + } + + // deliver to intended recipient + c.mu.Lock() + rpc, ok := c.pending[m.id] + if ok { + delete(c.pending, m.id) + } + + // wake a new muxer if there are more RPCs to read + c.muxer = false + for _, rpc := range c.pending { + c.muxer = true + rpc.Done <- &yourTurn + break + } + c.mu.Unlock() + if !ok { + println("Native Client: unexpected response for ID", m.id) + return + } + rpc.Ret = m.value + rpc.Done <- rpc +} + +// Wait blocks until the RPC has finished. +func (r *srpc) Wait() { + r.c.wait(r) +} + +// Start issues an RPC request for method name with the given arguments. +// The RPC r must not be in use for another pending request. +// To wait for the RPC to finish, receive from r.Done and then +// inspect r.Ret and r.Errno. +func (r *srpc) Start(name string, arg []interface{}) { + r.Err = nil + r.c.mu.Lock() + srv, ok := r.c.service[name] + if !ok { + r.c.mu.Unlock() + r.Err = srpcErrBadRPCNumber + r.Done <- r + return + } + r.c.pending[r.id] = r + if !r.c.muxer { + r.c.muxer = true + r.Done <- &yourTurn + } + r.c.mu.Unlock() + + var m msg + m.id = r.id + m.isRequest = 1 + m.rpc = srv.num + m.value = arg + + // Fill in the return values and sizes to generate + // the right type chars. We'll take most any size. + + // Skip over input arguments. + // We could check them against arg, but the server + // will do that anyway. + i := 0 + for srv.fmt[i] != ':' { + i++ + } + format := srv.fmt[i+1:] + + // Now the return prototypes. + m.template = make([]interface{}, len(format)) + m.size = make([]int, len(format)) + for i := 0; i < len(format); i++ { + switch format[i] { + default: + println("Native Client SRPC: unexpected service type " + string(format[i])) + r.Err = srpcErrBadRPCNumber + r.Done <- r + return + case 'b': + m.template[i] = false + case 'C': + m.template[i] = []byte(nil) + m.size[i] = 1 << 30 + case 'd': + m.template[i] = float64(0) + case 'D': + m.template[i] = []float64(nil) + m.size[i] = 1 << 30 + case 'h': + m.template[i] = int(-1) + case 'i': + m.template[i] = int32(0) + case 'I': + m.template[i] = []int32(nil) + m.size[i] = 1 << 30 + case 's': + m.template[i] = "" + m.size[i] = 1 << 30 + } + } + + if err := m.pack(); err != nil { + r.Err = errors.New("Native Client RPC Start " + name + ": preparing request: " + err.Error()) + r.Done <- r + return + } + + r.c.outMu.Lock() + r.c.s.send(&m) + r.c.outMu.Unlock() +} + +// Call is a convenience wrapper that starts the RPC request, +// waits for it to finish, and then returns the results. +// Its implementation is: +// +// r.Start(name, arg) +// r.Wait() +// return r.Ret, r.Errno +// +func (c *srpcClient) Call(name string, arg ...interface{}) (ret []interface{}, err error) { + r := c.NewRPC(nil) + r.Start(name, arg) + r.Wait() + return r.Ret, r.Err +} + +// NewRPC creates a new RPC on the client connection. +func (c *srpcClient) NewRPC(done chan *srpc) *srpc { + if done == nil { + done = make(chan *srpc, 1) + } + c.mu.Lock() + id := c.idGen + c.idGen++ + c.mu.Unlock() + return &srpc{Done: done, c: c, id: id} +} + +// The current protocol number. +// Kind of useless, since there have been backwards-incompatible changes +// to the wire protocol that did not update the protocol number. +// At this point it's really just a sanity check. +const protocol = 0xc0da0002 + +// An srpcErrno is an SRPC status code. +type srpcErrno uint32 + +const ( + srpcOK srpcErrno = 256 + iota + srpcErrBreak + srpcErrMessageTruncated + srpcErrNoMemory + srpcErrProtocolMismatch + srpcErrBadRPCNumber + srpcErrBadArgType + srpcErrTooFewArgs + srpcErrTooManyArgs + srpcErrInArgTypeMismatch + srpcErrOutArgTypeMismatch + srpcErrInternalError + srpcErrAppError +) + +var srpcErrstr = [...]string{ + srpcOK - srpcOK: "ok", + srpcErrBreak - srpcOK: "break", + srpcErrMessageTruncated - srpcOK: "message truncated", + srpcErrNoMemory - srpcOK: "out of memory", + srpcErrProtocolMismatch - srpcOK: "protocol mismatch", + srpcErrBadRPCNumber - srpcOK: "invalid RPC method number", + srpcErrBadArgType - srpcOK: "unexpected argument type", + srpcErrTooFewArgs - srpcOK: "too few arguments", + srpcErrTooManyArgs - srpcOK: "too many arguments", + srpcErrInArgTypeMismatch - srpcOK: "input argument type mismatch", + srpcErrOutArgTypeMismatch - srpcOK: "output argument type mismatch", + srpcErrInternalError - srpcOK: "internal error", + srpcErrAppError - srpcOK: "application error", +} + +func (e srpcErrno) Error() string { + if e < srpcOK || int(e-srpcOK) >= len(srpcErrstr) { + return "srpcErrno(" + itoa(int(e)) + ")" + } + return srpcErrstr[e-srpcOK] +} + +// A msgHdr is the data argument to the imc_recvmsg +// and imc_sendmsg system calls. +type msgHdr struct { + iov *iov + niov int32 + desc *int32 + ndesc int32 + flags uint32 +} + +// A single region for I/O. +type iov struct { + base *byte + len int32 +} + +const maxMsgSize = 1<<16 - 4*4 + +// A msgReceiver receives messages from a file descriptor. +type msgReceiver struct { + fd int + data [maxMsgSize]byte + desc [8]int32 + hdr msgHdr + iov iov +} + +func (r *msgReceiver) recv() (*msg, error) { + // Init pointers to buffers where syscall recvmsg can write. + r.iov.base = &r.data[0] + r.iov.len = int32(len(r.data)) + r.hdr.iov = &r.iov + r.hdr.niov = 1 + r.hdr.desc = &r.desc[0] + r.hdr.ndesc = int32(len(r.desc)) + n, _, e := Syscall(sys_imc_recvmsg, uintptr(r.fd), uintptr(unsafe.Pointer(&r.hdr)), 0) + if e != 0 { + println("Native Client imc_recvmsg: ", e.Error()) + return nil, e + } + + // Make a copy of the data so that the next recvmsg doesn't + // smash it. The system call did not update r.iov.len. Instead it + // returned the total byte count as n. + m := new(msg) + m.data = make([]byte, n) + copy(m.data, r.data[0:]) + + // Make a copy of the desc too. + // The system call *did* update r.hdr.ndesc. + if r.hdr.ndesc > 0 { + m.desc = make([]int32, r.hdr.ndesc) + copy(m.desc, r.desc[:]) + } + + return m, nil +} + +// A msgSender sends messages on a file descriptor. +type msgSender struct { + fd int + hdr msgHdr + iov iov +} + +func (s *msgSender) send(m *msg) error { + if len(m.data) > 0 { + s.iov.base = &m.data[0] + } + s.iov.len = int32(len(m.data)) + s.hdr.iov = &s.iov + s.hdr.niov = 1 + s.hdr.desc = nil + s.hdr.ndesc = 0 + _, _, e := Syscall(sys_imc_sendmsg, uintptr(s.fd), uintptr(unsafe.Pointer(&s.hdr)), 0) + if e != 0 { + println("Native Client imc_sendmsg: ", e.Error()) + return e + } + return nil +} + +// A msg is the Go representation of an SRPC message. +type msg struct { + data []byte // message data + desc []int32 // message file descriptors + + // parsed version of message + id uint32 + isRequest uint32 + rpc uint32 + status uint32 + value []interface{} + template []interface{} + size []int + format string + broken bool +} + +// reading from a msg + +func (m *msg) uint32() uint32 { + if m.broken { + return 0 + } + if len(m.data) < 4 { + m.broken = true + return 0 + } + b := m.data[:4] + x := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 + m.data = m.data[4:] + return x +} + +func (m *msg) uint64() uint64 { + x := uint64(m.uint32()) | uint64(m.uint32())<<32 + if m.broken { + return 0 + } + return x +} + +func (m *msg) bytes(n int) []byte { + if m.broken { + return nil + } + if len(m.data) < n { + m.broken = true + return nil + } + x := m.data[0:n] + m.data = m.data[n:] + return x +} + +// writing to a msg + +func (m *msg) wuint32(x uint32) { + m.data = append(m.data, byte(x), byte(x>>8), byte(x>>16), byte(x>>24)) +} + +func (m *msg) wuint64(x uint64) { + lo := uint32(x) + hi := uint32(x >> 32) + m.data = append(m.data, byte(lo), byte(lo>>8), byte(lo>>16), byte(lo>>24), byte(hi), byte(hi>>8), byte(hi>>16), byte(hi>>24)) +} + +func (m *msg) wbytes(p []byte) { + m.data = append(m.data, p...) +} + +func (m *msg) wstring(s string) { + m.data = append(m.data, s...) +} + +// Parsing of RPC messages. +// +// Each message begins with +// total_size uint32 +// total_descs uint32 +// fragment_size uint32 +// fragment_descs uint32 +// +// If fragment_size < total_size or fragment_descs < total_descs, the actual +// message is broken up in multiple messages; follow-up messages omit +// the "total" fields and begin with the "fragment" fields. +// We do not support putting fragmented messages back together. +// To do this we would need to change the message receiver. +// +// After that size information, the message header follows: +// protocol uint32 +// requestID uint32 +// isRequest uint32 +// rpcNumber uint32 +// status uint32 +// numValue uint32 +// numTemplate uint32 +// +// After the header come numTemplate fixed-size arguments, +// numValue fixed-size arguments, and then the variable-sized +// part of the values. The templates describe the expected results +// and have no associated variable sized data in the request. +// +// Each fixed-size argument has the form: +// tag uint32 // really a char, like 'b' or 'C' +// pad uint32 // unused +// val1 uint32 +// val2 uint32 +// +// The tags are: +// 'b': bool; val1 == 0 or 1 +// 'C': []byte; val1 == len, data in variable-sized section +// 'd': float64; (val1, val2) is data +// 'D': []float64; val1 == len, data in variable-sized section +// 'h': int; val1 == file descriptor +// 'i': int32; descriptor in next entry in m.desc +// 'I': []int; val1 == len, data in variable-sized section +// 's': string; val1 == len, data in variable-sized section +// + +func (m *msg) pack() error { + m.data = m.data[:0] + m.desc = m.desc[:0] + + // sizes, to fill in later + m.wuint32(0) + m.wuint32(0) + m.wuint32(0) + m.wuint32(0) + + // message header + m.wuint32(protocol) + m.wuint32(m.id) + m.wuint32(m.isRequest) + m.wuint32(m.rpc) + m.wuint32(m.status) + m.wuint32(uint32(len(m.value))) + m.wuint32(uint32(len(m.template))) + + // fixed-size templates + for i, x := range m.template { + var tag, val1, val2 uint32 + switch x.(type) { + default: + return errors.New("unexpected template type") + case bool: + tag = 'b' + case []byte: + tag = 'C' + val1 = uint32(m.size[i]) + case float64: + tag = 'd' + case []float64: + tag = 'D' + val1 = uint32(m.size[i]) + case int: + tag = 'h' + case int32: + tag = 'i' + case []int32: + tag = 'I' + val1 = uint32(m.size[i]) + case string: + tag = 's' + val1 = uint32(m.size[i]) + } + m.wuint32(tag) + m.wuint32(0) + m.wuint32(val1) + m.wuint32(val2) + } + + // fixed-size values + for _, x := range m.value { + var tag, val1, val2 uint32 + switch x := x.(type) { + default: + return errors.New("unexpected value type") + case bool: + tag = 'b' + if x { + val1 = 1 + } + case []byte: + tag = 'C' + val1 = uint32(len(x)) + case float64: + tag = 'd' + v := float64bits(x) + val1 = uint32(v) + val2 = uint32(v >> 32) + case []float64: + tag = 'D' + val1 = uint32(len(x)) + case int32: + tag = 'i' + m.desc = append(m.desc, x) + case []int32: + tag = 'I' + val1 = uint32(len(x)) + case string: + tag = 's' + val1 = uint32(len(x) + 1) + } + m.wuint32(tag) + m.wuint32(0) + m.wuint32(val1) + m.wuint32(val2) + } + + // variable-length data for values + for _, x := range m.value { + switch x := x.(type) { + case []byte: + m.wbytes(x) + case []float64: + for _, f := range x { + m.wuint64(float64bits(f)) + } + case []int32: + for _, j := range x { + m.wuint32(uint32(j)) + } + case string: + m.wstring(x) + m.wstring("\x00") + } + } + + // fill in sizes + data := m.data + m.data = m.data[:0] + m.wuint32(uint32(len(data))) + m.wuint32(uint32(len(m.desc))) + m.wuint32(uint32(len(data))) + m.wuint32(uint32(len(m.desc))) + m.data = data + + return nil +} + +func (m *msg) unpack() error { + totalSize := m.uint32() + totalDesc := m.uint32() + fragSize := m.uint32() + fragDesc := m.uint32() + if totalSize != fragSize || totalDesc != fragDesc { + return errors.New("Native Client: fragmented RPC messages not supported") + } + if m.uint32() != protocol { + return errors.New("Native Client: RPC protocol mismatch") + } + + // message header + m.id = m.uint32() + m.isRequest = m.uint32() + m.rpc = m.uint32() + m.status = m.uint32() + m.value = make([]interface{}, m.uint32()) + m.template = make([]interface{}, m.uint32()) + m.size = make([]int, len(m.template)) + if m.broken { + return errors.New("Native Client: malformed message") + } + + // fixed-size templates + for i := range m.template { + tag := m.uint32() + m.uint32() // padding + val1 := m.uint32() + m.uint32() // val2 + switch tag { + default: + return errors.New("Native Client: unexpected template type " + string(rune(tag))) + case 'b': + m.template[i] = false + case 'C': + m.template[i] = []byte(nil) + m.size[i] = int(val1) + case 'd': + m.template[i] = float64(0) + case 'D': + m.template[i] = []float64(nil) + m.size[i] = int(val1) + case 'i': + m.template[i] = int32(0) + case 'I': + m.template[i] = []int32(nil) + m.size[i] = int(val1) + case 'h': + m.template[i] = int(0) + case 's': + m.template[i] = "" + m.size[i] = int(val1) + } + } + + // fixed-size values + var ( + strsize []uint32 + d int + ) + for i := range m.value { + tag := m.uint32() + m.uint32() // padding + val1 := m.uint32() + val2 := m.uint32() + switch tag { + default: + return errors.New("Native Client: unexpected value type " + string(rune(tag))) + case 'b': + m.value[i] = val1 > 0 + case 'C': + m.value[i] = []byte(nil) + strsize = append(strsize, val1) + case 'd': + m.value[i] = float64frombits(uint64(val1) | uint64(val2)<<32) + case 'D': + m.value[i] = make([]float64, val1) + case 'i': + m.value[i] = int32(val1) + case 'I': + m.value[i] = make([]int32, val1) + case 'h': + m.value[i] = int(m.desc[d]) + d++ + case 's': + m.value[i] = "" + strsize = append(strsize, val1) + } + } + + // variable-sized parts of values + for i, x := range m.value { + switch x := x.(type) { + case []byte: + m.value[i] = m.bytes(int(strsize[0])) + strsize = strsize[1:] + case []float64: + for i := range x { + x[i] = float64frombits(m.uint64()) + } + case []int32: + for i := range x { + x[i] = int32(m.uint32()) + } + case string: + m.value[i] = string(m.bytes(int(strsize[0]))) + strsize = strsize[1:] + } + } + + if len(m.data) > 0 { + return errors.New("Native Client: junk at end of message") + } + return nil +} + +func float64bits(x float64) uint64 { + return *(*uint64)(unsafe.Pointer(&x)) +} + +func float64frombits(x uint64) float64 { + return *(*float64)(unsafe.Pointer(&x)) +} + +// At startup, connect to the name service. +var nsClient = nsConnect() + +func nsConnect() *srpcClient { + var ns int32 = -1 + _, _, errno := Syscall(sys_nameservice, uintptr(unsafe.Pointer(&ns)), 0, 0) + if errno != 0 { + println("Native Client nameservice:", errno.Error()) + return nil + } + + sock, _, errno := Syscall(sys_imc_connect, uintptr(ns), 0, 0) + if errno != 0 { + println("Native Client nameservice connect:", errno.Error()) + return nil + } + + c, err := newClient(int(sock)) + if err != nil { + println("Native Client nameservice init:", err.Error()) + return nil + } + + return c +} + +const ( + nsSuccess = 0 + nsNameNotFound = 1 + nsDuplicateName = 2 + nsInsufficientResources = 3 + nsPermissionDenied = 4 + nsInvalidArgument = 5 +) + +func openNamedService(name string, mode int32) (fd int, err error) { + if nsClient == nil { + return 0, errors.New("no name service") + } + ret, err := nsClient.Call("lookup:si:ih", name, int32(mode)) + if err != nil { + return 0, err + } + status := ret[0].(int32) + fd = ret[1].(int) + switch status { + case nsSuccess: + // ok + case nsNameNotFound: + return -1, ENOENT + case nsDuplicateName: + return -1, EEXIST + case nsInsufficientResources: + return -1, EWOULDBLOCK + case nsPermissionDenied: + return -1, EPERM + case nsInvalidArgument: + return -1, EINVAL + default: + return -1, EINVAL + } + return fd, nil +} diff --git a/src/pkg/syscall/syscall_bsd.go b/src/pkg/syscall/syscall_bsd.go index 76b1f41b4..b042841a5 100644 --- a/src/pkg/syscall/syscall_bsd.go +++ b/src/pkg/syscall/syscall_bsd.go @@ -64,8 +64,11 @@ func Setgroups(gids []int) (err error) { func ReadDirent(fd int, buf []byte) (n int, err error) { // Final argument is (basep *uintptr) and the syscall doesn't take nil. + // 64 bits should be enough. (32 bits isn't even on 386). Since the + // actual system call is getdirentries64, 64 is a good guess. // TODO(rsc): Can we use a single global basep for all calls? - return Getdirentries(fd, buf, new(uintptr)) + var base = (*uintptr)(unsafe.Pointer(new(uint64))) + return Getdirentries(fd, buf, base) } // Wait status is 7 bits at bottom, either 0 (exited), @@ -131,18 +134,18 @@ func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, } //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) -//sys bind(s int, addr uintptr, addrlen _Socklen) (err error) -//sys connect(s int, addr uintptr, addrlen _Socklen) (err error) +//sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) +//sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) //sysnb socket(domain int, typ int, proto int) (fd int, err error) -//sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) -//sys setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) +//sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) +//sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) //sys Shutdown(s int, how int) (err error) -func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Port < 0 || sa.Port > 0xFFFF { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Len = SizeofSockaddrInet4 sa.raw.Family = AF_INET @@ -152,12 +155,12 @@ func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), nil + return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } -func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Port < 0 || sa.Port > 0xFFFF { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Len = SizeofSockaddrInet6 sa.raw.Family = AF_INET6 @@ -168,26 +171,26 @@ func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), nil + return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } -func (sa *SockaddrUnix) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { name := sa.Name n := len(name) if n >= len(sa.raw.Path) || n == 0 { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL sa.raw.Family = AF_UNIX for i := 0; i < n; i++ { sa.raw.Path[i] = int8(name[i]) } - return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), nil + return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } -func (sa *SockaddrDatalink) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Index == 0 { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Len = sa.Len sa.raw.Family = AF_LINK @@ -199,7 +202,7 @@ func (sa *SockaddrDatalink) sockaddr() (uintptr, _Socklen, error) { for i := 0; i < len(sa.raw.Data); i++ { sa.raw.Data[i] = sa.Data[i] } - return uintptr(unsafe.Pointer(&sa.raw)), SizeofSockaddrDatalink, nil + return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil } func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { @@ -221,14 +224,20 @@ func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { case AF_UNIX: pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) - if pp.Len < 3 || pp.Len > SizeofSockaddrUnix { + if pp.Len < 2 || pp.Len > SizeofSockaddrUnix { return nil, EINVAL } sa := new(SockaddrUnix) - n := int(pp.Len) - 3 // subtract leading Family, Len, terminating NUL + + // Some BSDs include the trailing NUL in the length, whereas + // others do not. Work around this by subtracting the leading + // family and len. The path is then scanned to see if a NUL + // terminator still exists within the length. + n := int(pp.Len) - 2 // subtract leading Family, Len for i := 0; i < n; i++ { if pp.Path[i] == 0 { - // found early NUL; assume Len is overestimating + // found early NUL; assume Len included the NUL + // or was overestimating. n = i break } @@ -290,10 +299,9 @@ func Getsockname(fd int) (sa Sockaddr, err error) { if err = getsockname(fd, &rsa, &len); err != nil { return } - // TODO(jsing): Remove after OpenBSD 5.4 is released (see issue 3349). - // TODO(jsing): Apparently dragonfly has the same "bug", which should - // be reported upstream. - if (runtime.GOOS == "dragonfly" || runtime.GOOS == "openbsd") && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 { + // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be + // reported upstream. + if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 { rsa.Addr.Family = AF_UNIX rsa.Addr.Len = SizeofSockaddrUnix } @@ -305,46 +313,46 @@ func Getsockname(fd int) (sa Sockaddr, err error) { func GetsockoptByte(fd, level, opt int) (value byte, err error) { var n byte vallen := _Socklen(1) - err = getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), &vallen) + err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen) return n, err } func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) { vallen := _Socklen(4) - err = getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value[0])), &vallen) + err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) return value, err } func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) { var value IPMreq vallen := _Socklen(SizeofIPMreq) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) { var value IPv6Mreq vallen := _Socklen(SizeofIPv6Mreq) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) { var value IPv6MTUInfo vallen := _Socklen(SizeofIPv6MTUInfo) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) { var value ICMPv6Filter vallen := _Socklen(SizeofICMPv6Filter) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) -//sys sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) +//sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { @@ -381,15 +389,20 @@ func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from return } -//sys sendmsg(s int, msg *Msghdr, flags int) (err error) +//sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { - var ptr uintptr + _, err = SendmsgN(fd, p, oob, to, flags) + return +} + +func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { + var ptr unsafe.Pointer var salen _Socklen if to != nil { ptr, salen, err = to.sockaddr() if err != nil { - return + return 0, err } } var msg Msghdr @@ -412,21 +425,24 @@ func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { } msg.Iov = &iov msg.Iovlen = 1 - if err = sendmsg(fd, &msg, flags); err != nil { - return + if n, err = sendmsg(fd, &msg, flags); err != nil { + return 0, err } - return + if len(oob) > 0 && len(p) == 0 { + n = 0 + } + return n, nil } -//sys kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) +//sys kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) { - var change, event uintptr + var change, event unsafe.Pointer if len(changes) > 0 { - change = uintptr(unsafe.Pointer(&changes[0])) + change = unsafe.Pointer(&changes[0]) } if len(events) > 0 { - event = uintptr(unsafe.Pointer(&events[0])) + event = unsafe.Pointer(&events[0]) } return kevent(kq, change, len(changes), event, len(events), timeout) } diff --git a/src/pkg/syscall/syscall_bsd_test.go b/src/pkg/syscall/syscall_bsd_test.go new file mode 100644 index 000000000..c2ea089d5 --- /dev/null +++ b/src/pkg/syscall/syscall_bsd_test.go @@ -0,0 +1,34 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build darwin dragonfly freebsd openbsd + +package syscall_test + +import ( + "syscall" + "testing" +) + +const MNT_WAIT = 1 + +func TestGetfsstat(t *testing.T) { + n, err := syscall.Getfsstat(nil, MNT_WAIT) + if err != nil { + t.Fatal(err) + } + + data := make([]syscall.Statfs_t, n) + n, err = syscall.Getfsstat(data, MNT_WAIT) + if err != nil { + t.Fatal(err) + } + + empty := syscall.Statfs_t{} + for _, stat := range data { + if stat == empty { + t.Fatal("an empty Statfs_t struct was returned") + } + } +} diff --git a/src/pkg/syscall/syscall_darwin.go b/src/pkg/syscall/syscall_darwin.go index bd929ff99..97414dcda 100644 --- a/src/pkg/syscall/syscall_darwin.go +++ b/src/pkg/syscall/syscall_darwin.go @@ -187,6 +187,21 @@ func Pipe(p []int) (err error) { return } +func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { + var _p0 unsafe.Pointer + var bufsize uintptr + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) + bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf)) + } + r0, _, e1 := Syscall(SYS_GETFSSTAT64, uintptr(_p0), bufsize, uintptr(flags)) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + /* * Wrapped */ @@ -224,7 +239,6 @@ func Kill(pid int, signum Signal) (err error) { return kill(pid, int(signum), 1) //sys Getdtablesize() (size int) //sysnb Getegid() (egid int) //sysnb Geteuid() (uid int) -//sys Getfsstat(buf []Statfs_t, flags int) (n int, err error) = SYS_GETFSSTAT64 //sysnb Getgid() (gid int) //sysnb Getpgid(pid int) (pgid int, err error) //sysnb Getpgrp() (pgrp int) @@ -244,6 +258,11 @@ func Kill(pid int, signum Signal) (err error) { return kill(pid, int(signum), 1) //sys Mkdir(path string, mode uint32) (err error) //sys Mkfifo(path string, mode uint32) (err error) //sys Mknod(path string, mode uint32, dev int) (err error) +//sys Mlock(b []byte) (err error) +//sys Mlockall(flags int) (err error) +//sys Mprotect(b []byte, prot int) (err error) +//sys Munlock(b []byte) (err error) +//sys Munlockall() (err error) //sys Open(path string, mode int, perm uint32) (fd int, err error) //sys Pathconf(path string, name int) (val int, err error) //sys Pread(fd int, p []byte, offset int64) (n int, err error) diff --git a/src/pkg/syscall/syscall_dragonfly.go b/src/pkg/syscall/syscall_dragonfly.go index e19a9cee3..39c51df7e 100644 --- a/src/pkg/syscall/syscall_dragonfly.go +++ b/src/pkg/syscall/syscall_dragonfly.go @@ -101,6 +101,21 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) { return extpwrite(fd, p, 0, offset) } +func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { + var _p0 unsafe.Pointer + var bufsize uintptr + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) + bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf)) + } + r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), bufsize, uintptr(flags)) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + /* * Exposed directly */ @@ -129,7 +144,6 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) { //sys Getdtablesize() (size int) //sysnb Getegid() (egid int) //sysnb Geteuid() (uid int) -//sys Getfsstat(buf []Statfs_t, flags int) (n int, err error) //sysnb Getgid() (gid int) //sysnb Getpgid(pid int) (pgid int, err error) //sysnb Getpgrp() (pgrp int) diff --git a/src/pkg/syscall/syscall_freebsd.go b/src/pkg/syscall/syscall_freebsd.go index 9fbcc48c6..3d834f52b 100644 --- a/src/pkg/syscall/syscall_freebsd.go +++ b/src/pkg/syscall/syscall_freebsd.go @@ -95,12 +95,45 @@ func Pipe(p []int) (err error) { func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) { var value IPMreqn vallen := _Socklen(SizeofIPMreqn) - errno := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + errno := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, errno } func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(mreq)), unsafe.Sizeof(*mreq)) + return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) +} + +func Accept4(fd, flags int) (nfd int, sa Sockaddr, err error) { + var rsa RawSockaddrAny + var len _Socklen = SizeofSockaddrAny + nfd, err = accept4(fd, &rsa, &len, flags) + if err != nil { + return + } + if len > SizeofSockaddrAny { + panic("RawSockaddrAny too small") + } + sa, err = anyToSockaddr(&rsa) + if err != nil { + Close(nfd) + nfd = 0 + } + return +} + +func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { + var _p0 unsafe.Pointer + var bufsize uintptr + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) + bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf)) + } + r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), bufsize, uintptr(flags)) + n = int(r0) + if e1 != 0 { + err = e1 + } + return } /* @@ -131,7 +164,6 @@ func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { //sys Getdtablesize() (size int) //sysnb Getegid() (egid int) //sysnb Geteuid() (uid int) -//sys Getfsstat(buf []Statfs_t, flags int) (n int, err error) //sysnb Getgid() (gid int) //sysnb Getpgid(pid int) (pgid int, err error) //sysnb Getpgrp() (pgrp int) @@ -191,6 +223,7 @@ func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { //sys munmap(addr uintptr, length uintptr) (err error) //sys readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_READ //sys writelen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_WRITE +//sys accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) /* * Unimplemented diff --git a/src/pkg/syscall/syscall_linux.go b/src/pkg/syscall/syscall_linux.go index 79c1fda68..fa0d7ea3c 100644 --- a/src/pkg/syscall/syscall_linux.go +++ b/src/pkg/syscall/syscall_linux.go @@ -230,9 +230,9 @@ func Mkfifo(path string, mode uint32) (err error) { return Mknod(path, mode|S_IFIFO, 0) } -func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Port < 0 || sa.Port > 0xFFFF { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Family = AF_INET p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) @@ -241,12 +241,12 @@ func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), SizeofSockaddrInet4, nil + return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil } -func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Port < 0 || sa.Port > 0xFFFF { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Family = AF_INET6 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) @@ -256,14 +256,14 @@ func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), SizeofSockaddrInet6, nil + return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil } -func (sa *SockaddrUnix) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { name := sa.Name n := len(name) if n >= len(sa.raw.Path) { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Family = AF_UNIX for i := 0; i < n; i++ { @@ -280,7 +280,7 @@ func (sa *SockaddrUnix) sockaddr() (uintptr, _Socklen, error) { sl-- } - return uintptr(unsafe.Pointer(&sa.raw)), sl, nil + return unsafe.Pointer(&sa.raw), sl, nil } type SockaddrLinklayer struct { @@ -293,9 +293,9 @@ type SockaddrLinklayer struct { raw RawSockaddrLinklayer } -func (sa *SockaddrLinklayer) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Family = AF_PACKET sa.raw.Protocol = sa.Protocol @@ -306,7 +306,7 @@ func (sa *SockaddrLinklayer) sockaddr() (uintptr, _Socklen, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), SizeofSockaddrLinklayer, nil + return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil } type SockaddrNetlink struct { @@ -317,12 +317,12 @@ type SockaddrNetlink struct { raw RawSockaddrNetlink } -func (sa *SockaddrNetlink) sockaddr() (uintptr, _Socklen, error) { +func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) { sa.raw.Family = AF_NETLINK sa.raw.Pad = sa.Pad sa.raw.Pid = sa.Pid sa.raw.Groups = sa.Groups - return uintptr(unsafe.Pointer(&sa.raw)), SizeofSockaddrNetlink, nil + return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil } func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { @@ -420,6 +420,9 @@ func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) { if err != nil { return } + if len > SizeofSockaddrAny { + panic("RawSockaddrAny too small") + } sa, err = anyToSockaddr(&rsa) if err != nil { Close(nfd) @@ -439,54 +442,54 @@ func Getsockname(fd int) (sa Sockaddr, err error) { func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) { vallen := _Socklen(4) - err = getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value[0])), &vallen) + err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) return value, err } func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) { var value IPMreq vallen := _Socklen(SizeofIPMreq) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) { var value IPMreqn vallen := _Socklen(SizeofIPMreqn) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) { var value IPv6Mreq vallen := _Socklen(SizeofIPv6Mreq) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) { var value IPv6MTUInfo vallen := _Socklen(SizeofIPv6MTUInfo) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) { var value ICMPv6Filter vallen := _Socklen(SizeofICMPv6Filter) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func GetsockoptUcred(fd, level, opt int) (*Ucred, error) { var value Ucred vallen := _Socklen(SizeofUcred) - err := getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), &vallen) + err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) return &value, err } func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(mreq)), unsafe.Sizeof(*mreq)) + return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) } func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { @@ -524,13 +527,18 @@ func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from } func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { - var ptr uintptr + _, err = SendmsgN(fd, p, oob, to, flags) + return +} + +func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { + var ptr unsafe.Pointer var salen _Socklen if to != nil { var err error ptr, salen, err = to.sockaddr() if err != nil { - return err + return 0, err } } var msg Msghdr @@ -553,10 +561,13 @@ func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { } msg.Iov = &iov msg.Iovlen = 1 - if err = sendmsg(fd, &msg, flags); err != nil { - return + if n, err = sendmsg(fd, &msg, flags); err != nil { + return 0, err } - return + if len(oob) > 0 && len(p) == 0 { + n = 0 + } + return n, nil } // BindToDevice binds the socket associated with fd to device. diff --git a/src/pkg/syscall/syscall_linux_386.go b/src/pkg/syscall/syscall_linux_386.go index a61695676..c491a286c 100644 --- a/src/pkg/syscall/syscall_linux_386.go +++ b/src/pkg/syscall/syscall_linux_386.go @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP) +// so that go vet can check that they are correct. + package syscall import "unsafe" @@ -132,7 +135,15 @@ func Setrlimit(resource int, rlim *Rlimit) (err error) { // Underlying system call writes to newoffset via pointer. // Implemented in assembly to avoid allocation. -func Seek(fd int, offset int64, whence int) (newoffset int64, err error) +func seek(fd int, offset int64, whence int) (newoffset int64, err Errno) + +func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { + newoffset, errno := seek(fd, offset, whence) + if errno != 0 { + return 0, errno + } + return newoffset, nil +} // Vsyscalls on amd64. //sysnb Gettimeofday(tv *Timeval) (err error) @@ -212,7 +223,7 @@ func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) { return } -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, e := socketcall(_BIND, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0) if e != 0 { err = e @@ -220,7 +231,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { return } -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, e := socketcall(_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0) if e != 0 { err = e @@ -236,7 +247,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { return } -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, e := socketcall(_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e != 0 { err = e @@ -244,8 +255,8 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err return } -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { - _, e := socketcall(_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), val, vallen, 0) +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { + _, e := socketcall(_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen, 0) if e != 0 { err = e } @@ -264,12 +275,12 @@ func recvfrom(s int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockle return } -func sendto(s int, p []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, p []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var base uintptr if len(p) > 0 { base = uintptr(unsafe.Pointer(&p[0])) } - _, e := socketcall(_SENDTO, uintptr(s), base, uintptr(len(p)), uintptr(flags), to, uintptr(addrlen)) + _, e := socketcall(_SENDTO, uintptr(s), base, uintptr(len(p)), uintptr(flags), uintptr(to), uintptr(addrlen)) if e != 0 { err = e } @@ -284,8 +295,8 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { return } -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, e := socketcall(_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + n, e := socketcall(_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0) if e != 0 { err = e } diff --git a/src/pkg/syscall/syscall_linux_amd64.go b/src/pkg/syscall/syscall_linux_amd64.go index f4b73b20e..8915ed83b 100644 --- a/src/pkg/syscall/syscall_linux_amd64.go +++ b/src/pkg/syscall/syscall_linux_amd64.go @@ -40,26 +40,46 @@ package syscall //sys Truncate(path string, length int64) (err error) //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) //sys accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) -//sys bind(s int, addr uintptr, addrlen _Socklen) (err error) -//sys connect(s int, addr uintptr, addrlen _Socklen) (err error) +//sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) +//sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) //sysnb setgroups(n int, list *_Gid_t) (err error) -//sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) -//sys setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) +//sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) +//sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) //sysnb socket(domain int, typ int, proto int) (fd int, err error) //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) -//sys sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) +//sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) -//sys sendmsg(s int, msg *Msghdr, flags int) (err error) +//sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) //sys mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) func Getpagesize() int { return 4096 } -func Gettimeofday(tv *Timeval) (err error) -func Time(t *Time_t) (tt Time_t, err error) +//go:noescape +func gettimeofday(tv *Timeval) (err Errno) + +func Gettimeofday(tv *Timeval) (err error) { + errno := gettimeofday(tv) + if errno != 0 { + return errno + } + return nil +} + +func Time(t *Time_t) (tt Time_t, err error) { + var tv Timeval + errno := gettimeofday(&tv) + if errno != 0 { + return 0, errno + } + if t != nil { + *t = Time_t(tv.Sec) + } + return Time_t(tv.Sec), nil +} func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } diff --git a/src/pkg/syscall/syscall_linux_arm.go b/src/pkg/syscall/syscall_linux_arm.go index 4aadf9e4c..9fe80232a 100644 --- a/src/pkg/syscall/syscall_linux_arm.go +++ b/src/pkg/syscall/syscall_linux_arm.go @@ -23,26 +23,34 @@ func NsecToTimeval(nsec int64) (tv Timeval) { return } -// Seek is defined in assembly. - -func Seek(fd int, offset int64, whence int) (newoffset int64, err error) +// Underlying system call writes to newoffset via pointer. +// Implemented in assembly to avoid allocation. +func seek(fd int, offset int64, whence int) (newoffset int64, err Errno) + +func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { + newoffset, errno := seek(fd, offset, whence) + if errno != 0 { + return 0, errno + } + return newoffset, nil +} //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) //sys accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) -//sys bind(s int, addr uintptr, addrlen _Socklen) (err error) -//sys connect(s int, addr uintptr, addrlen _Socklen) (err error) +//sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) +//sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) //sysnb getgroups(n int, list *_Gid_t) (nn int, err error) = SYS_GETGROUPS32 //sysnb setgroups(n int, list *_Gid_t) (err error) = SYS_SETGROUPS32 -//sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) -//sys setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) +//sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) +//sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) //sysnb socket(domain int, typ int, proto int) (fd int, err error) //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) //sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) -//sys sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) +//sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) //sysnb socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) -//sys sendmsg(s int, msg *Msghdr, flags int) (err error) +//sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) // 64-bit file system and 32-bit uid calls // (16-bit uid calls are not always supported in newer kernels) diff --git a/src/pkg/syscall/syscall_nacl.go b/src/pkg/syscall/syscall_nacl.go new file mode 100644 index 000000000..c2788b20a --- /dev/null +++ b/src/pkg/syscall/syscall_nacl.go @@ -0,0 +1,311 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +import ( + "sync" + "unsafe" +) + +//sys naclClose(fd int) (err error) = sys_close +//sys Exit(code int) (err error) +//sys naclFstat(fd int, stat *Stat_t) (err error) = sys_fstat +//sys naclRead(fd int, b []byte) (n int, err error) = sys_read +//sys naclSeek(fd int, off *int64, whence int) (err error) = sys_lseek + +const direntSize = 8 + 8 + 2 + 256 + +// native_client/src/trusted/service_runtime/include/sys/dirent.h +type Dirent struct { + Ino int64 + Off int64 + Reclen uint16 + Name [256]byte +} + +func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) { + origlen := len(buf) + count = 0 + for max != 0 && len(buf) > 0 { + dirent := (*Dirent)(unsafe.Pointer(&buf[0])) + buf = buf[dirent.Reclen:] + if dirent.Ino == 0 { // File absent in directory. + continue + } + bytes := (*[512 + PathMax]byte)(unsafe.Pointer(&dirent.Name[0])) + var name = string(bytes[0:clen(bytes[:])]) + if name == "." || name == ".." { // Useless names + continue + } + max-- + count++ + names = append(names, name) + } + return origlen - len(buf), count, names +} + +func clen(n []byte) int { + for i := 0; i < len(n); i++ { + if n[i] == 0 { + return i + } + } + return len(n) +} + +const PathMax = 256 + +// An Errno is an unsigned number describing an error condition. +// It implements the error interface. The zero Errno is by convention +// a non-error, so code to convert from Errno to error should use: +// err = nil +// if errno != 0 { +// err = errno +// } +type Errno uintptr + +func (e Errno) Error() string { + if 0 <= int(e) && int(e) < len(errorstr) { + s := errorstr[e] + if s != "" { + return s + } + } + return "errno " + itoa(int(e)) +} + +func (e Errno) Temporary() bool { + return e == EINTR || e == EMFILE || e.Timeout() +} + +func (e Errno) Timeout() bool { + return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT +} + +// A Signal is a number describing a process signal. +// It implements the os.Signal interface. +type Signal int + +const ( + _ Signal = iota + SIGCHLD + SIGINT + SIGKILL + SIGTRAP + SIGQUIT +) + +func (s Signal) Signal() {} + +func (s Signal) String() string { + if 0 <= s && int(s) < len(signals) { + str := signals[s] + if str != "" { + return str + } + } + return "signal " + itoa(int(s)) +} + +var signals = [...]string{} + +// File system + +const ( + Stdin = 0 + Stdout = 1 + Stderr = 2 +) + +// native_client/src/trusted/service_runtime/include/sys/fcntl.h +const ( + O_RDONLY = 0 + O_WRONLY = 1 + O_RDWR = 2 + O_ACCMODE = 3 + + O_CREAT = 0100 + O_CREATE = O_CREAT // for ken + O_TRUNC = 01000 + O_APPEND = 02000 + O_EXCL = 0200 + O_NONBLOCK = 04000 + O_NDELAY = O_NONBLOCK + O_SYNC = 010000 + O_FSYNC = O_SYNC + O_ASYNC = 020000 + + O_CLOEXEC = 0 + + FD_CLOEXEC = 1 +) + +// native_client/src/trusted/service_runtime/include/sys/fcntl.h +const ( + F_DUPFD = 0 + F_GETFD = 1 + F_SETFD = 2 + F_GETFL = 3 + F_SETFL = 4 + F_GETOWN = 5 + F_SETOWN = 6 + F_GETLK = 7 + F_SETLK = 8 + F_SETLKW = 9 + F_RGETLK = 10 + F_RSETLK = 11 + F_CNVT = 12 + F_RSETLKW = 13 + + F_RDLCK = 1 + F_WRLCK = 2 + F_UNLCK = 3 + F_UNLKSYS = 4 +) + +// native_client/src/trusted/service_runtime/include/bits/stat.h +const ( + S_IFMT = 0000370000 + S_IFSHM_SYSV = 0000300000 + S_IFSEMA = 0000270000 + S_IFCOND = 0000260000 + S_IFMUTEX = 0000250000 + S_IFSHM = 0000240000 + S_IFBOUNDSOCK = 0000230000 + S_IFSOCKADDR = 0000220000 + S_IFDSOCK = 0000210000 + + S_IFSOCK = 0000140000 + S_IFLNK = 0000120000 + S_IFREG = 0000100000 + S_IFBLK = 0000060000 + S_IFDIR = 0000040000 + S_IFCHR = 0000020000 + S_IFIFO = 0000010000 + + S_UNSUP = 0000370000 + + S_ISUID = 0004000 + S_ISGID = 0002000 + S_ISVTX = 0001000 + + S_IREAD = 0400 + S_IWRITE = 0200 + S_IEXEC = 0100 + + S_IRWXU = 0700 + S_IRUSR = 0400 + S_IWUSR = 0200 + S_IXUSR = 0100 + + S_IRWXG = 070 + S_IRGRP = 040 + S_IWGRP = 020 + S_IXGRP = 010 + + S_IRWXO = 07 + S_IROTH = 04 + S_IWOTH = 02 + S_IXOTH = 01 +) + +// native_client/src/trusted/service_runtime/include/sys/stat.h +// native_client/src/trusted/service_runtime/include/machine/_types.h +type Stat_t struct { + Dev int64 + Ino uint64 + Mode uint32 + Nlink uint32 + Uid uint32 + Gid uint32 + Rdev int64 + Size int64 + Blksize int32 + Blocks int32 + Atime int64 + AtimeNsec int64 + Mtime int64 + MtimeNsec int64 + Ctime int64 + CtimeNsec int64 +} + +// Processes +// Not supported on NaCl - just enough for package os. + +var ForkLock sync.RWMutex + +type WaitStatus uint32 + +func (w WaitStatus) Exited() bool { return false } +func (w WaitStatus) ExitStatus() int { return 0 } +func (w WaitStatus) Signaled() bool { return false } +func (w WaitStatus) Signal() Signal { return 0 } +func (w WaitStatus) CoreDump() bool { return false } +func (w WaitStatus) Stopped() bool { return false } +func (w WaitStatus) Continued() bool { return false } +func (w WaitStatus) StopSignal() Signal { return 0 } +func (w WaitStatus) TrapCause() int { return 0 } + +// XXX made up +type Rusage struct { + Utime Timeval + Stime Timeval +} + +// XXX made up +type ProcAttr struct { + Dir string + Env []string + Files []uintptr + Sys *SysProcAttr +} + +type SysProcAttr struct { +} + +// System + +func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) +func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) { return 0, 0, ENOSYS } +func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) { return 0, 0, ENOSYS } +func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) { + return 0, 0, ENOSYS +} + +func Sysctl(key string) (string, error) { + if key == "kern.hostname" { + return "naclbox", nil + } + return "", ENOSYS +} + +// Unimplemented Unix midden heap. + +const ImplementsGetwd = false + +func Getwd() (wd string, err error) { return "", ENOSYS } +func Getegid() int { return 1 } +func Geteuid() int { return 1 } +func Getgid() int { return 1 } +func Getgroups() ([]int, error) { return []int{1}, nil } +func Getpagesize() int { return 65536 } +func Getppid() int { return 2 } +func Getpid() int { return 3 } +func Getuid() int { return 1 } +func Kill(pid int, signum Signal) error { return ENOSYS } +func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { + return 0, ENOSYS +} +func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) { + return 0, 0, ENOSYS +} +func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { + return 0, ENOSYS +} +func RouteRIB(facility, param int) ([]byte, error) { return nil, ENOSYS } +func ParseRoutingMessage(b []byte) ([]RoutingMessage, error) { return nil, ENOSYS } +func ParseRoutingSockaddr(msg RoutingMessage) ([]Sockaddr, error) { return nil, ENOSYS } +func SysctlUint32(name string) (value uint32, err error) { return 0, ENOSYS } diff --git a/src/pkg/syscall/syscall_nacl_386.go b/src/pkg/syscall/syscall_nacl_386.go new file mode 100644 index 000000000..d12f8e2d6 --- /dev/null +++ b/src/pkg/syscall/syscall_nacl_386.go @@ -0,0 +1,32 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +type Timespec struct { + Sec int64 + Nsec int32 +} + +type Timeval struct { + Sec int64 + Usec int32 +} + +func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } + +func NsecToTimespec(nsec int64) (ts Timespec) { + ts.Sec = int64(nsec / 1e9) + ts.Nsec = int32(nsec % 1e9) + return +} + +func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 } + +func NsecToTimeval(nsec int64) (tv Timeval) { + nsec += 999 // round up to microsecond + tv.Usec = int32(nsec % 1e9 / 1e3) + tv.Sec = int64(nsec / 1e9) + return +} diff --git a/src/pkg/syscall/syscall_nacl_amd64p32.go b/src/pkg/syscall/syscall_nacl_amd64p32.go new file mode 100644 index 000000000..d12f8e2d6 --- /dev/null +++ b/src/pkg/syscall/syscall_nacl_amd64p32.go @@ -0,0 +1,32 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +type Timespec struct { + Sec int64 + Nsec int32 +} + +type Timeval struct { + Sec int64 + Usec int32 +} + +func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } + +func NsecToTimespec(nsec int64) (ts Timespec) { + ts.Sec = int64(nsec / 1e9) + ts.Nsec = int32(nsec % 1e9) + return +} + +func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 } + +func NsecToTimeval(nsec int64) (tv Timeval) { + nsec += 999 // round up to microsecond + tv.Usec = int32(nsec % 1e9 / 1e3) + tv.Sec = int64(nsec / 1e9) + return +} diff --git a/src/pkg/syscall/syscall_openbsd.go b/src/pkg/syscall/syscall_openbsd.go index 89c73215a..8d3f825f8 100644 --- a/src/pkg/syscall/syscall_openbsd.go +++ b/src/pkg/syscall/syscall_openbsd.go @@ -90,11 +90,31 @@ func Pipe(p []int) (err error) { return } +//sys getdents(fd int, buf []byte) (n int, err error) +func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { + return getdents(fd, buf) +} + // TODO func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { return -1, ENOSYS } +func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { + var _p0 unsafe.Pointer + var bufsize uintptr + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) + bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf)) + } + r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), bufsize, uintptr(flags)) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + /* * Exposed directly */ @@ -119,10 +139,8 @@ func sendfile(outfd int, infd int, offset *int64, count int) (written int, err e //sys Fstatfs(fd int, stat *Statfs_t) (err error) //sys Fsync(fd int) (err error) //sys Ftruncate(fd int, length int64) (err error) -//sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) //sysnb Getegid() (egid int) //sysnb Geteuid() (uid int) -//sys Getfsstat(buf []Statfs_t, flags int) (n int, err error) //sysnb Getgid() (gid int) //sysnb Getpgid(pid int) (pgid int, err error) //sysnb Getpgrp() (pgrp int) diff --git a/src/pkg/syscall/syscall_openbsd_386.go b/src/pkg/syscall/syscall_openbsd_386.go index 3c4c693c9..ad5ae14bf 100644 --- a/src/pkg/syscall/syscall_openbsd_386.go +++ b/src/pkg/syscall/syscall_openbsd_386.go @@ -9,7 +9,7 @@ func Getpagesize() int { return 4096 } func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } func NsecToTimespec(nsec int64) (ts Timespec) { - ts.Sec = int32(nsec / 1e9) + ts.Sec = int64(nsec / 1e9) ts.Nsec = int32(nsec % 1e9) return } @@ -19,7 +19,7 @@ func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec) func NsecToTimeval(nsec int64) (tv Timeval) { nsec += 999 // round up to microsecond tv.Usec = int32(nsec % 1e9 / 1e3) - tv.Sec = int32(nsec / 1e9) + tv.Sec = int64(nsec / 1e9) return } diff --git a/src/pkg/syscall/syscall_openbsd_amd64.go b/src/pkg/syscall/syscall_openbsd_amd64.go index c356ad4fa..6181344cd 100644 --- a/src/pkg/syscall/syscall_openbsd_amd64.go +++ b/src/pkg/syscall/syscall_openbsd_amd64.go @@ -9,7 +9,7 @@ func Getpagesize() int { return 4096 } func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } func NsecToTimespec(nsec int64) (ts Timespec) { - ts.Sec = int32(nsec / 1e9) + ts.Sec = nsec / 1e9 ts.Nsec = nsec % 1e9 return } @@ -19,12 +19,12 @@ func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec) func NsecToTimeval(nsec int64) (tv Timeval) { nsec += 999 // round up to microsecond tv.Usec = nsec % 1e9 / 1e3 - tv.Sec = int64(nsec / 1e9) + tv.Sec = nsec / 1e9 return } func SetKevent(k *Kevent_t, fd, mode, flags int) { - k.Ident = uint32(fd) + k.Ident = uint64(fd) k.Filter = int16(mode) k.Flags = uint16(flags) } diff --git a/src/pkg/syscall/syscall_plan9.go b/src/pkg/syscall/syscall_plan9.go index 2e1c064c4..a8c340541 100644 --- a/src/pkg/syscall/syscall_plan9.go +++ b/src/pkg/syscall/syscall_plan9.go @@ -83,7 +83,7 @@ func errstr() string { } // Implemented in assembly to import from runtime. -func exit(int) +func exit(code int) func Exit(code int) { exit(code) } diff --git a/src/pkg/syscall/syscall_solaris.go b/src/pkg/syscall/syscall_solaris.go new file mode 100644 index 000000000..adc52b1f7 --- /dev/null +++ b/src/pkg/syscall/syscall_solaris.go @@ -0,0 +1,523 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Solaris system calls. +// This file is compiled as ordinary Go code, +// but it is also input to mksyscall, +// which parses the //sys lines and generates system call stubs. +// Note that sometimes we use a lowercase //sys name and wrap +// it in our own nicer implementation, either here or in +// syscall_solaris.go or syscall_unix.go. + +package syscall + +import "unsafe" + +type SockaddrDatalink struct { + Family uint16 + Index uint16 + Type uint8 + Nlen uint8 + Alen uint8 + Slen uint8 + Data [244]int8 + raw RawSockaddrDatalink +} + +func clen(n []byte) int { + for i := 0; i < len(n); i++ { + if n[i] == 0 { + return i + } + } + return len(n) +} + +// ParseDirent parses up to max directory entries in buf, +// appending the names to names. It returns the number +// bytes consumed from buf, the number of entries added +// to names, and the new names slice. +func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) { + origlen := len(buf) + for max != 0 && len(buf) > 0 { + dirent := (*Dirent)(unsafe.Pointer(&buf[0])) + if dirent.Reclen == 0 { + buf = nil + break + } + buf = buf[dirent.Reclen:] + if dirent.Ino == 0 { // File absent in directory. + continue + } + bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0])) + var name = string(bytes[0:clen(bytes[:])]) + if name == "." || name == ".." { // Useless names + continue + } + max-- + count++ + names = append(names, name) + } + return origlen - len(buf), count, names +} + +func pipe() (r uintptr, w uintptr, err uintptr) + +func Pipe(p []int) (err error) { + if len(p) != 2 { + return EINVAL + } + r0, w0, e1 := pipe() + if e1 != 0 { + err = Errno(e1) + } + p[0], p[1] = int(r0), int(w0) + return +} + +func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { + if sa.Port < 0 || sa.Port > 0xFFFF { + return nil, 0, EINVAL + } + sa.raw.Family = AF_INET + p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) + p[0] = byte(sa.Port >> 8) + p[1] = byte(sa.Port) + for i := 0; i < len(sa.Addr); i++ { + sa.raw.Addr[i] = sa.Addr[i] + } + return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil +} + +func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { + if sa.Port < 0 || sa.Port > 0xFFFF { + return nil, 0, EINVAL + } + sa.raw.Family = AF_INET6 + p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) + p[0] = byte(sa.Port >> 8) + p[1] = byte(sa.Port) + sa.raw.Scope_id = sa.ZoneId + for i := 0; i < len(sa.Addr); i++ { + sa.raw.Addr[i] = sa.Addr[i] + } + return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil +} + +func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { + name := sa.Name + n := len(name) + if n >= len(sa.raw.Path) { + return nil, 0, EINVAL + } + sa.raw.Family = AF_UNIX + for i := 0; i < n; i++ { + sa.raw.Path[i] = int8(name[i]) + } + // length is family (uint16), name, NUL. + sl := _Socklen(2) + if n > 0 { + sl += _Socklen(n) + 1 + } + if sa.raw.Path[0] == '@' { + sa.raw.Path[0] = 0 + // Don't count trailing NUL for abstract address. + sl-- + } + + return unsafe.Pointer(&sa.raw), sl, nil +} + +func Getsockname(fd int) (sa Sockaddr, err error) { + var rsa RawSockaddrAny + var len _Socklen = SizeofSockaddrAny + if err = getsockname(fd, &rsa, &len); err != nil { + return + } + return anyToSockaddr(&rsa) +} + +// The const provides a compile-time constant so clients +// can adjust to whether there is a working Getwd and avoid +// even linking this function into the binary. See ../os/getwd.go. +const ImplementsGetwd = false + +func Getwd() (string, error) { return "", ENOTSUP } + +/* + * Wrapped + */ + +//sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error) +//sysnb setgroups(ngid int, gid *_Gid_t) (err error) + +func Getgroups() (gids []int, err error) { + n, err := getgroups(0, nil) + if err != nil { + return nil, err + } + if n == 0 { + return nil, nil + } + + // Sanity check group count. Max is 16 on BSD. + if n < 0 || n > 1000 { + return nil, EINVAL + } + + a := make([]_Gid_t, n) + n, err = getgroups(n, &a[0]) + if err != nil { + return nil, err + } + gids = make([]int, n) + for i, v := range a[0:n] { + gids[i] = int(v) + } + return +} + +func Setgroups(gids []int) (err error) { + if len(gids) == 0 { + return setgroups(0, nil) + } + + a := make([]_Gid_t, len(gids)) + for i, v := range gids { + a[i] = _Gid_t(v) + } + return setgroups(len(a), &a[0]) +} + +func ReadDirent(fd int, buf []byte) (n int, err error) { + // Final argument is (basep *uintptr) and the syscall doesn't take nil. + // TODO(rsc): Can we use a single global basep for all calls? + return Getdents(fd, buf, new(uintptr)) +} + +// Wait status is 7 bits at bottom, either 0 (exited), +// 0x7F (stopped), or a signal number that caused an exit. +// The 0x80 bit is whether there was a core dump. +// An extra number (exit code, signal causing a stop) +// is in the high bits. + +type WaitStatus uint32 + +const ( + mask = 0x7F + core = 0x80 + shift = 8 + + exited = 0 + stopped = 0x7F +) + +func (w WaitStatus) Exited() bool { return w&mask == exited } + +func (w WaitStatus) ExitStatus() int { + if w&mask != exited { + return -1 + } + return int(w >> shift) +} + +func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 } + +func (w WaitStatus) Signal() Signal { + sig := Signal(w & mask) + if sig == stopped || sig == 0 { + return -1 + } + return sig +} + +func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } + +func (w WaitStatus) Stopped() bool { return w&mask == stopped && Signal(w>>shift) != SIGSTOP } + +func (w WaitStatus) Continued() bool { return w&mask == stopped && Signal(w>>shift) == SIGSTOP } + +func (w WaitStatus) StopSignal() Signal { + if !w.Stopped() { + return -1 + } + return Signal(w>>shift) & 0xFF +} + +func (w WaitStatus) TrapCause() int { return -1 } + +func wait4(pid uintptr, wstatus *WaitStatus, options uintptr, rusage *Rusage) (wpid uintptr, err uintptr) + +func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { + r0, e1 := wait4(uintptr(pid), wstatus, uintptr(options), rusage) + if e1 != 0 { + err = Errno(e1) + } + return int(r0), err +} + +func gethostname() (name string, err uintptr) + +func Gethostname() (name string, err error) { + name, e1 := gethostname() + if e1 != 0 { + err = Errno(e1) + } + return name, err +} + +func UtimesNano(path string, ts []Timespec) (err error) { + if len(ts) != 2 { + return EINVAL + } + var tv [2]Timeval + for i := 0; i < 2; i++ { + tv[i].Sec = ts[i].Sec + tv[i].Usec = ts[i].Nsec / 1000 + } + return Utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) +} + +//sys fcntl(fd int, cmd int, arg int) (val int, err error) + +// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. +func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { + _, _, e1 := sysvicall6(procfcntl.Addr(), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0) + if e1 != 0 { + return e1 + } + return nil +} + +func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { + switch rsa.Addr.Family { + case AF_UNIX: + pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) + sa := new(SockaddrUnix) + // Assume path ends at NUL. + // This is not technically the Solaris semantics for + // abstract Unix domain sockets -- they are supposed + // to be uninterpreted fixed-size binary blobs -- but + // everyone uses this convention. + n := 0 + for n < len(pp.Path) && pp.Path[n] != 0 { + n++ + } + bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] + sa.Name = string(bytes) + return sa, nil + + case AF_INET: + pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) + sa := new(SockaddrInet4) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + for i := 0; i < len(sa.Addr); i++ { + sa.Addr[i] = pp.Addr[i] + } + return sa, nil + + case AF_INET6: + pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) + sa := new(SockaddrInet6) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + sa.ZoneId = pp.Scope_id + for i := 0; i < len(sa.Addr); i++ { + sa.Addr[i] = pp.Addr[i] + } + return sa, nil + } + return nil, EAFNOSUPPORT +} + +//sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = libsocket.accept + +func Accept(fd int) (nfd int, sa Sockaddr, err error) { + var rsa RawSockaddrAny + var len _Socklen = SizeofSockaddrAny + nfd, err = accept(fd, &rsa, &len) + if err != nil { + return + } + sa, err = anyToSockaddr(&rsa) + if err != nil { + Close(nfd) + nfd = 0 + } + return +} + +func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { + var msg Msghdr + var rsa RawSockaddrAny + msg.Name = (*byte)(unsafe.Pointer(&rsa)) + msg.Namelen = uint32(SizeofSockaddrAny) + var iov Iovec + if len(p) > 0 { + iov.Base = (*int8)(unsafe.Pointer(&p[0])) + iov.SetLen(len(p)) + } + var dummy int8 + if len(oob) > 0 { + // receive at least one normal byte + if len(p) == 0 { + iov.Base = &dummy + iov.SetLen(1) + } + msg.Accrights = (*int8)(unsafe.Pointer(&oob[0])) + } + msg.Iov = &iov + msg.Iovlen = 1 + if n, err = recvmsg(fd, &msg, flags); err != nil { + return + } + oobn = int(msg.Accrightslen) + // source address is only specified if the socket is unconnected + if rsa.Addr.Family != AF_UNSPEC { + from, err = anyToSockaddr(&rsa) + } + return +} + +func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { + _, err = SendmsgN(fd, p, oob, to, flags) + return +} + +//sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.sendmsg + +func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { + var ptr unsafe.Pointer + var salen _Socklen + if to != nil { + ptr, salen, err = to.sockaddr() + if err != nil { + return 0, err + } + } + var msg Msghdr + msg.Name = (*byte)(unsafe.Pointer(ptr)) + msg.Namelen = uint32(salen) + var iov Iovec + if len(p) > 0 { + iov.Base = (*int8)(unsafe.Pointer(&p[0])) + iov.SetLen(len(p)) + } + var dummy int8 + if len(oob) > 0 { + // send at least one normal byte + if len(p) == 0 { + iov.Base = &dummy + iov.SetLen(1) + } + msg.Accrights = (*int8)(unsafe.Pointer(&oob[0])) + } + msg.Iov = &iov + msg.Iovlen = 1 + if n, err = sendmsg(fd, &msg, flags); err != nil { + return 0, err + } + if len(oob) > 0 && len(p) == 0 { + n = 0 + } + return n, nil +} + +/* + * Exposed directly + */ +//sys Access(path string, mode uint32) (err error) +//sys Adjtime(delta *Timeval, olddelta *Timeval) (err error) +//sys Chdir(path string) (err error) +//sys Chmod(path string, mode uint32) (err error) +//sys Chown(path string, uid int, gid int) (err error) +//sys Chroot(path string) (err error) +//sys Close(fd int) (err error) +//sys Dup(fd int) (nfd int, err error) +//sys Exit(code int) +//sys Fchdir(fd int) (err error) +//sys Fchmod(fd int, mode uint32) (err error) +//sys Fchown(fd int, uid int, gid int) (err error) +//sys Fpathconf(fd int, name int) (val int, err error) +//sys Fstat(fd int, stat *Stat_t) (err error) +//sys Getdents(fd int, buf []byte, basep *uintptr) (n int, err error) +//sysnb Getgid() (gid int) +//sysnb Getpid() (pid int) +//sys Geteuid() (euid int) +//sys Getegid() (egid int) +//sys Getppid() (ppid int) +//sys Getpriority(which int, who int) (n int, err error) +//sysnb Getrlimit(which int, lim *Rlimit) (err error) +//sysnb Gettimeofday(tv *Timeval) (err error) +//sysnb Getuid() (uid int) +//sys Kill(pid int, signum Signal) (err error) +//sys Lchown(path string, uid int, gid int) (err error) +//sys Link(path string, link string) (err error) +//sys Listen(s int, backlog int) (err error) = libsocket.listen +//sys Lstat(path string, stat *Stat_t) (err error) +//sys Mkdir(path string, mode uint32) (err error) +//sys Mknod(path string, mode uint32, dev int) (err error) +//sys Nanosleep(time *Timespec, leftover *Timespec) (err error) +//sys Open(path string, mode int, perm uint32) (fd int, err error) +//sys Pathconf(path string, name int) (val int, err error) +//sys Pread(fd int, p []byte, offset int64) (n int, err error) +//sys Pwrite(fd int, p []byte, offset int64) (n int, err error) +//sys read(fd int, p []byte) (n int, err error) +//sys Readlink(path string, buf []byte) (n int, err error) +//sys Rename(from string, to string) (err error) +//sys Rmdir(path string) (err error) +//sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek +//sysnb Setegid(egid int) (err error) +//sysnb Seteuid(euid int) (err error) +//sysnb Setgid(gid int) (err error) +//sysnb Setpgid(pid int, pgid int) (err error) +//sys Setpriority(which int, who int, prio int) (err error) +//sysnb Setregid(rgid int, egid int) (err error) +//sysnb Setreuid(ruid int, euid int) (err error) +//sysnb Setrlimit(which int, lim *Rlimit) (err error) +//sysnb Setsid() (pid int, err error) +//sysnb Setuid(uid int) (err error) +//sys Shutdown(s int, how int) (err error) = libsocket.shutdown +//sys Stat(path string, stat *Stat_t) (err error) +//sys Symlink(path string, link string) (err error) +//sys Sync() (err error) +//sys Truncate(path string, length int64) (err error) +//sys Fsync(fd int) (err error) +//sys Ftruncate(fd int, length int64) (err error) +//sys Umask(newmask int) (oldmask int) +//sys Unlink(path string) (err error) +//sys Utimes(path string, times *[2]Timeval) (err error) +//sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.bind +//sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.connect +//sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) +//sys munmap(addr uintptr, length uintptr) (err error) +//sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.sendto +//sys socket(domain int, typ int, proto int) (fd int, err error) = libsocket.socket +//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) = libsocket.socketpair +//sys write(fd int, p []byte) (n int, err error) +//sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) = libsocket.getsockopt +//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getpeername +//sys getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getsockname +//sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) = libsocket.setsockopt +//sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = libsocket.recvfrom +//sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.recvmsg + +func readlen(fd int, buf *byte, nbuf int) (n int, err error) { + r0, _, e1 := sysvicall6(procread.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func writelen(fd int, buf *byte, nbuf int) (n int, err error) { + r0, _, e1 := sysvicall6(procwrite.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} diff --git a/src/pkg/syscall/syscall_solaris_amd64.go b/src/pkg/syscall/syscall_solaris_amd64.go new file mode 100644 index 000000000..37cf06d70 --- /dev/null +++ b/src/pkg/syscall/syscall_solaris_amd64.go @@ -0,0 +1,37 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +func Getpagesize() int { return 4096 } + +func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } + +func NsecToTimespec(nsec int64) (ts Timespec) { + ts.Sec = nsec / 1e9 + ts.Nsec = nsec % 1e9 + return +} + +func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 } + +func NsecToTimeval(nsec int64) (tv Timeval) { + nsec += 999 // round up to microsecond + tv.Usec = nsec % 1e9 / 1e3 + tv.Sec = int64(nsec / 1e9) + return +} + +func (iov *Iovec) SetLen(length int) { + iov.Len = uint64(length) +} + +func (cmsg *Cmsghdr) SetLen(length int) { + cmsg.Len = uint32(length) +} + +func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { + // TODO(aram): implement this, see issue 5847. + panic("unimplemented") +} diff --git a/src/pkg/syscall/syscall_unix.go b/src/pkg/syscall/syscall_unix.go index 6455dc29c..b28891568 100644 --- a/src/pkg/syscall/syscall_unix.go +++ b/src/pkg/syscall/syscall_unix.go @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build darwin dragonfly freebsd linux netbsd openbsd +// +build darwin dragonfly freebsd linux netbsd openbsd solaris package syscall @@ -19,8 +19,9 @@ var ( ) const ( - darwin64Bit = runtime.GOOS == "darwin" && sizeofPtr == 8 - netbsd32Bit = runtime.GOOS == "netbsd" && sizeofPtr == 4 + darwin64Bit = runtime.GOOS == "darwin" && sizeofPtr == 8 + dragonfly64Bit = runtime.GOOS == "dragonfly" && sizeofPtr == 8 + netbsd32Bit = runtime.GOOS == "netbsd" && sizeofPtr == 4 ) func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) @@ -55,7 +56,7 @@ func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (d cap int }{addr, length, length} - // Use unsafe to turn sl into a []byte. + // Use unsafeto turn sl into a []byte. b := *(*[]byte)(unsafe.Pointer(&sl)) // Register mapping in m and return it. @@ -160,7 +161,7 @@ func Write(fd int, p []byte) (n int, err error) { var SocketDisableIPv6 bool type Sockaddr interface { - sockaddr() (ptr uintptr, len _Socklen, err error) // lowercase; only we can define Sockaddrs + sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs } type SockaddrInet4 struct { @@ -209,7 +210,7 @@ func Getpeername(fd int) (sa Sockaddr, err error) { func GetsockoptInt(fd, level, opt int) (value int, err error) { var n int32 vallen := _Socklen(4) - err = getsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), &vallen) + err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen) return int(n), err } @@ -234,40 +235,40 @@ func Sendto(fd int, p []byte, flags int, to Sockaddr) (err error) { } func SetsockoptByte(fd, level, opt int, value byte) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value)), 1) + return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1) } func SetsockoptInt(fd, level, opt int, value int) (err error) { var n = int32(value) - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), 4) + return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4) } func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&value[0])), 4) + return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4) } func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(mreq)), SizeofIPMreq) + return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq) } func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(mreq)), SizeofIPv6Mreq) + return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq) } func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(filter)), SizeofICMPv6Filter) + return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter) } func SetsockoptLinger(fd, level, opt int, l *Linger) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(l)), SizeofLinger) + return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger) } func SetsockoptString(fd, level, opt int, s string) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&[]byte(s)[0])), uintptr(len(s))) + return setsockopt(fd, level, opt, unsafe.Pointer(&[]byte(s)[0]), uintptr(len(s))) } func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (err error) { - return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(tv)), unsafe.Sizeof(*tv)) + return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv)) } func Socket(domain, typ, proto int) (fd int, err error) { diff --git a/src/pkg/syscall/passfd_test.go b/src/pkg/syscall/syscall_unix_test.go index 53c7a1ffa..a0afb91fc 100644 --- a/src/pkg/syscall/passfd_test.go +++ b/src/pkg/syscall/syscall_unix_test.go @@ -1,8 +1,8 @@ -// Copyright 2012 The Go Authors. All rights reserved. +// Copyright 2013 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build linux dragonfly darwin freebsd netbsd openbsd +// +build darwin dragonfly freebsd linux netbsd openbsd solaris package syscall_test @@ -13,12 +13,70 @@ import ( "net" "os" "os/exec" + "path/filepath" "runtime" "syscall" "testing" "time" ) +// Tests that below functions, structures and constants are consistent +// on all Unix-like systems. +func _() { + // program scheduling priority functions and constants + var ( + _ func(int, int, int) error = syscall.Setpriority + _ func(int, int) (int, error) = syscall.Getpriority + ) + const ( + _ int = syscall.PRIO_USER + _ int = syscall.PRIO_PROCESS + _ int = syscall.PRIO_PGRP + ) + + // termios constants + const ( + _ int = syscall.TCIFLUSH + _ int = syscall.TCIOFLUSH + _ int = syscall.TCOFLUSH + ) + + // fcntl file locking structure and constants + var ( + _ = syscall.Flock_t{ + Type: int16(0), + Whence: int16(0), + Start: int64(0), + Len: int64(0), + Pid: int32(0), + } + ) + const ( + _ = syscall.F_GETLK + _ = syscall.F_SETLK + _ = syscall.F_SETLKW + ) +} + +// TestFcntlFlock tests whether the file locking structure matches +// the calling convention of each kernel. +func TestFcntlFlock(t *testing.T) { + name := filepath.Join(os.TempDir(), "TestFcntlFlock") + fd, err := syscall.Open(name, syscall.O_CREAT|syscall.O_RDWR|syscall.O_CLOEXEC, 0) + if err != nil { + t.Fatalf("Open failed: %v", err) + } + defer syscall.Unlink(name) + defer syscall.Close(fd) + flock := syscall.Flock_t{ + Type: syscall.F_RDLCK, + Start: 0, Len: 0, Whence: 1, + } + if err := syscall.FcntlFlock(uintptr(fd), syscall.F_GETLK, &flock); err != nil { + t.Fatalf("FcntlFlock failed: %v", err) + } +} + // TestPassFD tests passing a file descriptor over a Unix socket. // // This test involved both a parent and child process. The parent @@ -27,9 +85,13 @@ import ( // "-test.run=^TestPassFD$" and an environment variable used to signal // that the test should become the child process instead. func TestPassFD(t *testing.T) { - if runtime.GOOS == "dragonfly" { + switch runtime.GOOS { + case "dragonfly": // TODO(jsing): Figure out why sendmsg is returning EINVAL. - t.Skip("Skipping test on dragonfly") + t.Skip("skipping test on dragonfly") + case "solaris": + // TODO(aram): Figure out why ReadMsgUnix is returning empty message. + t.Skip("skipping test on solaris, see issue 7402") } if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" { passFDChild() @@ -200,3 +262,53 @@ func TestUnixRightsRoundtrip(t *testing.T) { } } } + +func TestRlimit(t *testing.T) { + var rlimit, zero syscall.Rlimit + err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit) + if err != nil { + t.Fatalf("Getrlimit: save failed: %v", err) + } + if zero == rlimit { + t.Fatalf("Getrlimit: save failed: got zero value %#v", rlimit) + } + set := rlimit + set.Cur = set.Max - 1 + err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &set) + if err != nil { + t.Fatalf("Setrlimit: set failed: %#v %v", set, err) + } + var get syscall.Rlimit + err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &get) + if err != nil { + t.Fatalf("Getrlimit: get failed: %v", err) + } + set = rlimit + set.Cur = set.Max - 1 + if set != get { + // Seems like Darwin requires some privilege to + // increase the soft limit of rlimit sandbox, though + // Setrlimit never reports an error. + switch runtime.GOOS { + case "darwin": + default: + t.Fatalf("Rlimit: change failed: wanted %#v got %#v", set, get) + } + } + err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlimit) + if err != nil { + t.Fatalf("Setrlimit: restore failed: %#v %v", rlimit, err) + } +} + +func TestSeekFailure(t *testing.T) { + _, err := syscall.Seek(-1, 0, 0) + if err == nil { + t.Fatalf("Seek(-1, 0, 0) did not fail") + } + str := err.Error() // used to crash on Linux + t.Logf("Seek: %v", str) + if str == "" { + t.Fatalf("Seek(-1, 0, 0) return error with empty message") + } +} diff --git a/src/pkg/syscall/syscall_windows.go b/src/pkg/syscall/syscall_windows.go index 3d78b6823..f9733f6ce 100644 --- a/src/pkg/syscall/syscall_windows.go +++ b/src/pkg/syscall/syscall_windows.go @@ -106,10 +106,11 @@ func (e Errno) Timeout() bool { } // Converts a Go function to a function pointer conforming -// to the stdcall calling convention. This is useful when +// to the stdcall or cdecl calling convention. This is useful when // interoperating with Windows code requiring callbacks. // Implemented in ../runtime/syscall_windows.goc func NewCallback(fn interface{}) uintptr +func NewCallbackCDecl(fn interface{}) uintptr // windows api calls @@ -522,8 +523,8 @@ const socket_error = uintptr(^uint32(0)) //sys socket(af int32, typ int32, protocol int32) (handle Handle, err error) [failretval==InvalidHandle] = ws2_32.socket //sys Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) [failretval==socket_error] = ws2_32.setsockopt //sys Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockopt -//sys bind(s Handle, name uintptr, namelen int32) (err error) [failretval==socket_error] = ws2_32.bind -//sys connect(s Handle, name uintptr, namelen int32) (err error) [failretval==socket_error] = ws2_32.connect +//sys bind(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.bind +//sys connect(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.connect //sys getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockname //sys getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getpeername //sys listen(s Handle, backlog int32) (err error) [failretval==socket_error] = ws2_32.listen @@ -578,7 +579,7 @@ type RawSockaddrAny struct { } type Sockaddr interface { - sockaddr() (ptr uintptr, len int32, err error) // lowercase; only we can define Sockaddrs + sockaddr() (ptr unsafe.Pointer, len int32, err error) // lowercase; only we can define Sockaddrs } type SockaddrInet4 struct { @@ -587,9 +588,9 @@ type SockaddrInet4 struct { raw RawSockaddrInet4 } -func (sa *SockaddrInet4) sockaddr() (uintptr, int32, error) { +func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, int32, error) { if sa.Port < 0 || sa.Port > 0xFFFF { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Family = AF_INET p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) @@ -598,7 +599,7 @@ func (sa *SockaddrInet4) sockaddr() (uintptr, int32, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), int32(unsafe.Sizeof(sa.raw)), nil + return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil } type SockaddrInet6 struct { @@ -608,9 +609,9 @@ type SockaddrInet6 struct { raw RawSockaddrInet6 } -func (sa *SockaddrInet6) sockaddr() (uintptr, int32, error) { +func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, int32, error) { if sa.Port < 0 || sa.Port > 0xFFFF { - return 0, 0, EINVAL + return nil, 0, EINVAL } sa.raw.Family = AF_INET6 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) @@ -620,16 +621,16 @@ func (sa *SockaddrInet6) sockaddr() (uintptr, int32, error) { for i := 0; i < len(sa.Addr); i++ { sa.raw.Addr[i] = sa.Addr[i] } - return uintptr(unsafe.Pointer(&sa.raw)), int32(unsafe.Sizeof(sa.raw)), nil + return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil } type SockaddrUnix struct { Name string } -func (sa *SockaddrUnix) sockaddr() (uintptr, int32, error) { +func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, int32, error) { // TODO(brainman): implement SockaddrUnix.sockaddr() - return 0, 0, EWINDOWS + return nil, 0, EWINDOWS } func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) { @@ -753,7 +754,7 @@ func LoadConnectEx() error { return connectExFunc.err } -func connectEx(s Handle, name uintptr, namelen int32, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) (err error) { +func connectEx(s Handle, name unsafe.Pointer, namelen int32, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) (err error) { r1, _, e1 := Syscall9(connectExFunc.addr, 7, uintptr(s), uintptr(name), uintptr(namelen), uintptr(unsafe.Pointer(sendBuf)), uintptr(sendDataLen), uintptr(unsafe.Pointer(bytesSent)), uintptr(unsafe.Pointer(overlapped)), 0, 0) if r1 == 0 { if e1 != 0 { diff --git a/src/pkg/syscall/tables_nacl.go b/src/pkg/syscall/tables_nacl.go new file mode 100644 index 000000000..08f4ced53 --- /dev/null +++ b/src/pkg/syscall/tables_nacl.go @@ -0,0 +1,324 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +// TODO: generate with runtime/mknacl.sh, allow override with IRT. +const ( + sys_null = 1 + sys_nameservice = 2 + sys_dup = 8 + sys_dup2 = 9 + sys_open = 10 + sys_close = 11 + sys_read = 12 + sys_write = 13 + sys_lseek = 14 + sys_ioctl = 15 + sys_stat = 16 + sys_fstat = 17 + sys_chmod = 18 + sys_brk = 20 + sys_mmap = 21 + sys_munmap = 22 + sys_getdents = 23 + sys_mprotect = 24 + sys_list_mappings = 25 + sys_exit = 30 + sys_getpid = 31 + sys_sched_yield = 32 + sys_sysconf = 33 + sys_gettimeofday = 40 + sys_clock = 41 + sys_nanosleep = 42 + sys_clock_getres = 43 + sys_clock_gettime = 44 + sys_mkdir = 45 + sys_rmdir = 46 + sys_chdir = 47 + sys_getcwd = 48 + sys_unlink = 49 + sys_imc_makeboundsock = 60 + sys_imc_accept = 61 + sys_imc_connect = 62 + sys_imc_sendmsg = 63 + sys_imc_recvmsg = 64 + sys_imc_mem_obj_create = 65 + sys_imc_socketpair = 66 + sys_mutex_create = 70 + sys_mutex_lock = 71 + sys_mutex_trylock = 72 + sys_mutex_unlock = 73 + sys_cond_create = 74 + sys_cond_wait = 75 + sys_cond_signal = 76 + sys_cond_broadcast = 77 + sys_cond_timed_wait_abs = 79 + sys_thread_create = 80 + sys_thread_exit = 81 + sys_tls_init = 82 + sys_thread_nice = 83 + sys_tls_get = 84 + sys_second_tls_set = 85 + sys_second_tls_get = 86 + sys_exception_handler = 87 + sys_exception_stack = 88 + sys_exception_clear_flag = 89 + sys_sem_create = 100 + sys_sem_wait = 101 + sys_sem_post = 102 + sys_sem_get_value = 103 + sys_dyncode_create = 104 + sys_dyncode_modify = 105 + sys_dyncode_delete = 106 + sys_test_infoleak = 109 + sys_test_crash = 110 + sys_test_syscall_1 = 111 + sys_test_syscall_2 = 112 +) + +// TODO: Auto-generate some day. (Hard-coded in binaries so not likely to change.) +const ( + // native_client/src/trusted/service_runtime/include/sys/errno.h + // The errors are mainly copied from Linux. + EPERM Errno = 1 /* Operation not permitted */ + ENOENT Errno = 2 /* No such file or directory */ + ESRCH Errno = 3 /* No such process */ + EINTR Errno = 4 /* Interrupted system call */ + EIO Errno = 5 /* I/O error */ + ENXIO Errno = 6 /* No such device or address */ + E2BIG Errno = 7 /* Argument list too long */ + ENOEXEC Errno = 8 /* Exec format error */ + EBADF Errno = 9 /* Bad file number */ + ECHILD Errno = 10 /* No child processes */ + EAGAIN Errno = 11 /* Try again */ + ENOMEM Errno = 12 /* Out of memory */ + EACCES Errno = 13 /* Permission denied */ + EFAULT Errno = 14 /* Bad address */ + EBUSY Errno = 16 /* Device or resource busy */ + EEXIST Errno = 17 /* File exists */ + EXDEV Errno = 18 /* Cross-device link */ + ENODEV Errno = 19 /* No such device */ + ENOTDIR Errno = 20 /* Not a directory */ + EISDIR Errno = 21 /* Is a directory */ + EINVAL Errno = 22 /* Invalid argument */ + ENFILE Errno = 23 /* File table overflow */ + EMFILE Errno = 24 /* Too many open files */ + ENOTTY Errno = 25 /* Not a typewriter */ + EFBIG Errno = 27 /* File too large */ + ENOSPC Errno = 28 /* No space left on device */ + ESPIPE Errno = 29 /* Illegal seek */ + EROFS Errno = 30 /* Read-only file system */ + EMLINK Errno = 31 /* Too many links */ + EPIPE Errno = 32 /* Broken pipe */ + ENAMETOOLONG Errno = 36 /* File name too long */ + ENOSYS Errno = 38 /* Function not implemented */ + EDQUOT Errno = 122 /* Quota exceeded */ + EDOM Errno = 33 /* Math arg out of domain of func */ + ERANGE Errno = 34 /* Math result not representable */ + EDEADLK Errno = 35 /* Deadlock condition */ + ENOLCK Errno = 37 /* No record locks available */ + ENOTEMPTY Errno = 39 /* Directory not empty */ + ELOOP Errno = 40 /* Too many symbolic links */ + ENOMSG Errno = 42 /* No message of desired type */ + EIDRM Errno = 43 /* Identifier removed */ + ECHRNG Errno = 44 /* Channel number out of range */ + EL2NSYNC Errno = 45 /* Level 2 not synchronized */ + EL3HLT Errno = 46 /* Level 3 halted */ + EL3RST Errno = 47 /* Level 3 reset */ + ELNRNG Errno = 48 /* Link number out of range */ + EUNATCH Errno = 49 /* Protocol driver not attached */ + ENOCSI Errno = 50 /* No CSI structure available */ + EL2HLT Errno = 51 /* Level 2 halted */ + EBADE Errno = 52 /* Invalid exchange */ + EBADR Errno = 53 /* Invalid request descriptor */ + EXFULL Errno = 54 /* Exchange full */ + ENOANO Errno = 55 /* No anode */ + EBADRQC Errno = 56 /* Invalid request code */ + EBADSLT Errno = 57 /* Invalid slot */ + EDEADLOCK Errno = EDEADLK /* File locking deadlock error */ + EBFONT Errno = 59 /* Bad font file fmt */ + ENOSTR Errno = 60 /* Device not a stream */ + ENODATA Errno = 61 /* No data (for no delay io) */ + ETIME Errno = 62 /* Timer expired */ + ENOSR Errno = 63 /* Out of streams resources */ + ENONET Errno = 64 /* Machine is not on the network */ + ENOPKG Errno = 65 /* Package not installed */ + EREMOTE Errno = 66 /* The object is remote */ + ENOLINK Errno = 67 /* The link has been severed */ + EADV Errno = 68 /* Advertise error */ + ESRMNT Errno = 69 /* Srmount error */ + ECOMM Errno = 70 /* Communication error on send */ + EPROTO Errno = 71 /* Protocol error */ + EMULTIHOP Errno = 72 /* Multihop attempted */ + EDOTDOT Errno = 73 /* Cross mount point (not really error) */ + EBADMSG Errno = 74 /* Trying to read unreadable message */ + EOVERFLOW Errno = 75 /* Value too large for defined data type */ + ENOTUNIQ Errno = 76 /* Given log. name not unique */ + EBADFD Errno = 77 /* f.d. invalid for this operation */ + EREMCHG Errno = 78 /* Remote address changed */ + ELIBACC Errno = 79 /* Can't access a needed shared lib */ + ELIBBAD Errno = 80 /* Accessing a corrupted shared lib */ + ELIBSCN Errno = 81 /* .lib section in a.out corrupted */ + ELIBMAX Errno = 82 /* Attempting to link in too many libs */ + ELIBEXEC Errno = 83 /* Attempting to exec a shared library */ + EILSEQ Errno = 84 + EUSERS Errno = 87 + ENOTSOCK Errno = 88 /* Socket operation on non-socket */ + EDESTADDRREQ Errno = 89 /* Destination address required */ + EMSGSIZE Errno = 90 /* Message too long */ + EPROTOTYPE Errno = 91 /* Protocol wrong type for socket */ + ENOPROTOOPT Errno = 92 /* Protocol not available */ + EPROTONOSUPPORT Errno = 93 /* Unknown protocol */ + ESOCKTNOSUPPORT Errno = 94 /* Socket type not supported */ + EOPNOTSUPP Errno = 95 /* Operation not supported on transport endpoint */ + EPFNOSUPPORT Errno = 96 /* Protocol family not supported */ + EAFNOSUPPORT Errno = 97 /* Address family not supported by protocol family */ + EADDRINUSE Errno = 98 /* Address already in use */ + EADDRNOTAVAIL Errno = 99 /* Address not available */ + ENETDOWN Errno = 100 /* Network interface is not configured */ + ENETUNREACH Errno = 101 /* Network is unreachable */ + ENETRESET Errno = 102 + ECONNABORTED Errno = 103 /* Connection aborted */ + ECONNRESET Errno = 104 /* Connection reset by peer */ + ENOBUFS Errno = 105 /* No buffer space available */ + EISCONN Errno = 106 /* Socket is already connected */ + ENOTCONN Errno = 107 /* Socket is not connected */ + ESHUTDOWN Errno = 108 /* Can't send after socket shutdown */ + ETOOMANYREFS Errno = 109 + ETIMEDOUT Errno = 110 /* Connection timed out */ + ECONNREFUSED Errno = 111 /* Connection refused */ + EHOSTDOWN Errno = 112 /* Host is down */ + EHOSTUNREACH Errno = 113 /* Host is unreachable */ + EALREADY Errno = 114 /* Socket already connected */ + EINPROGRESS Errno = 115 /* Connection already in progress */ + ESTALE Errno = 116 + ENOTSUP Errno = EOPNOTSUPP /* Not supported */ + ENOMEDIUM Errno = 123 /* No medium (in tape drive) */ + ECANCELED Errno = 125 /* Operation canceled. */ + ELBIN Errno = 2048 /* Inode is remote (not really error) */ + EFTYPE Errno = 2049 /* Inappropriate file type or format */ + ENMFILE Errno = 2050 /* No more files */ + EPROCLIM Errno = 2051 + ENOSHARE Errno = 2052 /* No such host or network path */ + ECASECLASH Errno = 2053 /* Filename exists with different case */ + EWOULDBLOCK Errno = EAGAIN /* Operation would block */ +) + +// TODO: Auto-generate some day. (Hard-coded in binaries so not likely to change.) +var errorstr = [...]string{ + EPERM: "Operation not permitted", + ENOENT: "No such file or directory", + ESRCH: "No such process", + EINTR: "Interrupted system call", + EIO: "I/O error", + ENXIO: "No such device or address", + E2BIG: "Argument list too long", + ENOEXEC: "Exec format error", + EBADF: "Bad file number", + ECHILD: "No child processes", + EAGAIN: "Try again", + ENOMEM: "Out of memory", + EACCES: "Permission denied", + EFAULT: "Bad address", + EBUSY: "Device or resource busy", + EEXIST: "File exists", + EXDEV: "Cross-device link", + ENODEV: "No such device", + ENOTDIR: "Not a directory", + EISDIR: "Is a directory", + EINVAL: "Invalid argument", + ENFILE: "File table overflow", + EMFILE: "Too many open files", + ENOTTY: "Not a typewriter", + EFBIG: "File too large", + ENOSPC: "No space left on device", + ESPIPE: "Illegal seek", + EROFS: "Read-only file system", + EMLINK: "Too many links", + EPIPE: "Broken pipe", + ENAMETOOLONG: "File name too long", + ENOSYS: "not implemented on Native Client", + EDQUOT: "Quota exceeded", + EDOM: "Math arg out of domain of func", + ERANGE: "Math result not representable", + EDEADLK: "Deadlock condition", + ENOLCK: "No record locks available", + ENOTEMPTY: "Directory not empty", + ELOOP: "Too many symbolic links", + ENOMSG: "No message of desired type", + EIDRM: "Identifier removed", + ECHRNG: "Channel number out of range", + EL2NSYNC: "Level 2 not synchronized", + EL3HLT: "Level 3 halted", + EL3RST: "Level 3 reset", + ELNRNG: "Link number out of range", + EUNATCH: "Protocol driver not attached", + ENOCSI: "No CSI structure available", + EL2HLT: "Level 2 halted", + EBADE: "Invalid exchange", + EBADR: "Invalid request descriptor", + EXFULL: "Exchange full", + ENOANO: "No anode", + EBADRQC: "Invalid request code", + EBADSLT: "Invalid slot", + EBFONT: "Bad font file fmt", + ENOSTR: "Device not a stream", + ENODATA: "No data (for no delay io)", + ETIME: "Timer expired", + ENOSR: "Out of streams resources", + ENONET: "Machine is not on the network", + ENOPKG: "Package not installed", + EREMOTE: "The object is remote", + ENOLINK: "The link has been severed", + EADV: "Advertise error", + ESRMNT: "Srmount error", + ECOMM: "Communication error on send", + EPROTO: "Protocol error", + EMULTIHOP: "Multihop attempted", + EDOTDOT: "Cross mount point (not really error)", + EBADMSG: "Trying to read unreadable message", + EOVERFLOW: "Value too large for defined data type", + ENOTUNIQ: "Given log. name not unique", + EBADFD: "f.d. invalid for this operation", + EREMCHG: "Remote address changed", + ELIBACC: "Can't access a needed shared lib", + ELIBBAD: "Accessing a corrupted shared lib", + ELIBSCN: ".lib section in a.out corrupted", + ELIBMAX: "Attempting to link in too many libs", + ELIBEXEC: "Attempting to exec a shared library", + ENOTSOCK: "Socket operation on non-socket", + EDESTADDRREQ: "Destination address required", + EMSGSIZE: "Message too long", + EPROTOTYPE: "Protocol wrong type for socket", + ENOPROTOOPT: "Protocol not available", + EPROTONOSUPPORT: "Unknown protocol", + ESOCKTNOSUPPORT: "Socket type not supported", + EOPNOTSUPP: "Operation not supported on transport endpoint", + EPFNOSUPPORT: "Protocol family not supported", + EAFNOSUPPORT: "Address family not supported by protocol family", + EADDRINUSE: "Address already in use", + EADDRNOTAVAIL: "Address not available", + ENETDOWN: "Network interface is not configured", + ENETUNREACH: "Network is unreachable", + ECONNABORTED: "Connection aborted", + ECONNRESET: "Connection reset by peer", + ENOBUFS: "No buffer space available", + EISCONN: "Socket is already connected", + ENOTCONN: "Socket is not connected", + ESHUTDOWN: "Can't send after socket shutdown", + ETIMEDOUT: "Connection timed out", + ECONNREFUSED: "Connection refused", + EHOSTDOWN: "Host is down", + EHOSTUNREACH: "Host is unreachable", + EALREADY: "Socket already connected", + EINPROGRESS: "Connection already in progress", + ENOMEDIUM: "No medium (in tape drive)", + ECANCELED: "Operation canceled.", + ELBIN: "Inode is remote (not really error)", + EFTYPE: "Inappropriate file type or format", + ENMFILE: "No more files", + ENOSHARE: "No such host or network path", + ECASECLASH: "Filename exists with different case", +} diff --git a/src/pkg/syscall/time_nacl_386.s b/src/pkg/syscall/time_nacl_386.s new file mode 100644 index 000000000..b5a22d31b --- /dev/null +++ b/src/pkg/syscall/time_nacl_386.s @@ -0,0 +1,11 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "../../cmd/ld/textflag.h" + +TEXT ·startTimer(SB),NOSPLIT,$0 + JMP time·startTimer(SB) + +TEXT ·stopTimer(SB),NOSPLIT,$0 + JMP time·stopTimer(SB) diff --git a/src/pkg/syscall/time_nacl_amd64p32.s b/src/pkg/syscall/time_nacl_amd64p32.s new file mode 100644 index 000000000..b5a22d31b --- /dev/null +++ b/src/pkg/syscall/time_nacl_amd64p32.s @@ -0,0 +1,11 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include "../../cmd/ld/textflag.h" + +TEXT ·startTimer(SB),NOSPLIT,$0 + JMP time·startTimer(SB) + +TEXT ·stopTimer(SB),NOSPLIT,$0 + JMP time·stopTimer(SB) diff --git a/src/pkg/syscall/types_dragonfly.go b/src/pkg/syscall/types_dragonfly.go index 009b8f045..fb7fd1bb4 100644 --- a/src/pkg/syscall/types_dragonfly.go +++ b/src/pkg/syscall/types_dragonfly.go @@ -18,6 +18,7 @@ package syscall #include <dirent.h> #include <fcntl.h> #include <signal.h> +#include <termios.h> #include <stdio.h> #include <unistd.h> #include <sys/event.h> @@ -97,10 +98,6 @@ type _Gid_t C.gid_t // Files -const ( - F_DUPFD_CLOEXEC = 0 // not supported -) - const ( // Directory mode bits S_IFMT = C.S_IFMT S_IFIFO = C.S_IFIFO @@ -239,3 +236,7 @@ type BpfProgram C.struct_bpf_program type BpfInsn C.struct_bpf_insn type BpfHdr C.struct_bpf_hdr + +// Terminal handling + +type Termios C.struct_termios diff --git a/src/pkg/syscall/types_freebsd.go b/src/pkg/syscall/types_freebsd.go index ccf53d0ad..68a69312b 100644 --- a/src/pkg/syscall/types_freebsd.go +++ b/src/pkg/syscall/types_freebsd.go @@ -18,6 +18,7 @@ package syscall #include <dirent.h> #include <fcntl.h> #include <signal.h> +#include <termios.h> #include <stdio.h> #include <unistd.h> #include <sys/event.h> @@ -59,6 +60,91 @@ struct sockaddr_any { char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)]; }; +// This structure is a duplicate of stat on FreeBSD 8-STABLE. +// See /usr/include/sys/stat.h. +struct stat8 { +#undef st_atimespec st_atim +#undef st_mtimespec st_mtim +#undef st_ctimespec st_ctim +#undef st_birthtimespec st_birthtim + __dev_t st_dev; + ino_t st_ino; + mode_t st_mode; + nlink_t st_nlink; + uid_t st_uid; + gid_t st_gid; + __dev_t st_rdev; +#if __BSD_VISIBLE + struct timespec st_atimespec; + struct timespec st_mtimespec; + struct timespec st_ctimespec; +#else + time_t st_atime; + long __st_atimensec; + time_t st_mtime; + long __st_mtimensec; + time_t st_ctime; + long __st_ctimensec; +#endif + off_t st_size; + blkcnt_t st_blocks; + blksize_t st_blksize; + fflags_t st_flags; + __uint32_t st_gen; + __int32_t st_lspare; +#if __BSD_VISIBLE + struct timespec st_birthtimespec; + unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec)); + unsigned int :(8 / 2) * (16 - (int)sizeof(struct timespec)); +#else + time_t st_birthtime; + long st_birthtimensec; + unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec)); + unsigned int :(8 / 2) * (16 - (int)sizeof(struct __timespec)); +#endif +}; + +// This structure is a duplicate of if_data on FreeBSD 8-STABLE. +// See /usr/include/net/if.h. +struct if_data8 { + u_char ifi_type; + u_char ifi_physical; + u_char ifi_addrlen; + u_char ifi_hdrlen; + u_char ifi_link_state; + u_char ifi_spare_char1; + u_char ifi_spare_char2; + u_char ifi_datalen; + u_long ifi_mtu; + u_long ifi_metric; + u_long ifi_baudrate; + u_long ifi_ipackets; + u_long ifi_ierrors; + u_long ifi_opackets; + u_long ifi_oerrors; + u_long ifi_collisions; + u_long ifi_ibytes; + u_long ifi_obytes; + u_long ifi_imcasts; + u_long ifi_omcasts; + u_long ifi_iqdrops; + u_long ifi_noproto; + u_long ifi_hwassist; + time_t ifi_epoch; + struct timeval ifi_lastchange; +}; + +// This structure is a duplicate of if_msghdr on FreeBSD 8-STABLE. +// See /usr/include/net/if.h. +struct if_msghdr8 { + u_short ifm_msglen; + u_char ifm_version; + u_char ifm_type; + int ifm_addrs; + int ifm_flags; + u_short ifm_index; + struct if_data8 ifm_data; +}; */ import "C" @@ -97,10 +183,6 @@ type _Gid_t C.gid_t // Files -const ( - O_CLOEXEC = 0 // not supported -) - const ( // Directory mode bits S_IFMT = C.S_IFMT S_IFIFO = C.S_IFIFO @@ -118,7 +200,7 @@ const ( // Directory mode bits S_IXUSR = C.S_IXUSR ) -type Stat_t C.struct_stat +type Stat_t C.struct_stat8 type Statfs_t C.struct_statfs @@ -200,8 +282,10 @@ type FdSet C.fd_set // Routing and interface messages const ( - SizeofIfMsghdr = C.sizeof_struct_if_msghdr - SizeofIfData = C.sizeof_struct_if_data + sizeofIfMsghdr = C.sizeof_struct_if_msghdr + SizeofIfMsghdr = C.sizeof_struct_if_msghdr8 + sizeofIfData = C.sizeof_struct_if_data + SizeofIfData = C.sizeof_struct_if_data8 SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr SizeofIfmaMsghdr = C.sizeof_struct_ifma_msghdr SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr @@ -209,9 +293,13 @@ const ( SizeofRtMetrics = C.sizeof_struct_rt_metrics ) -type IfMsghdr C.struct_if_msghdr +type ifMsghdr C.struct_if_msghdr + +type IfMsghdr C.struct_if_msghdr8 -type IfData C.struct_if_data +type ifData C.struct_if_data + +type IfData C.struct_if_data8 type IfaMsghdr C.struct_ifa_msghdr @@ -248,3 +336,7 @@ type BpfInsn C.struct_bpf_insn type BpfHdr C.struct_bpf_hdr type BpfZbufHeader C.struct_bpf_zbuf_header + +// Terminal handling + +type Termios C.struct_termios diff --git a/src/pkg/syscall/types_linux.go b/src/pkg/syscall/types_linux.go index fea09d1d7..e8396a41f 100644 --- a/src/pkg/syscall/types_linux.go +++ b/src/pkg/syscall/types_linux.go @@ -158,6 +158,8 @@ type Dirent C.struct_dirent type Fsid C.fsid_t +type Flock_t C.struct_flock + // Sockets type RawSockaddrInet4 C.struct_sockaddr_in diff --git a/src/pkg/syscall/types_netbsd.go b/src/pkg/syscall/types_netbsd.go index badaa1049..04354a32a 100644 --- a/src/pkg/syscall/types_netbsd.go +++ b/src/pkg/syscall/types_netbsd.go @@ -18,6 +18,7 @@ package syscall #include <dirent.h> #include <fcntl.h> #include <signal.h> +#include <termios.h> #include <stdio.h> #include <unistd.h> #include <sys/param.h> @@ -222,6 +223,10 @@ type BpfHdr C.struct_bpf_hdr type BpfTimeval C.struct_bpf_timeval +// Terminal handling + +type Termios C.struct_termios + // Sysctl type Sysctlnode C.struct_sysctlnode diff --git a/src/pkg/syscall/types_openbsd.go b/src/pkg/syscall/types_openbsd.go index 6fe2af6e0..e6d1ea704 100644 --- a/src/pkg/syscall/types_openbsd.go +++ b/src/pkg/syscall/types_openbsd.go @@ -18,6 +18,7 @@ package syscall #include <dirent.h> #include <fcntl.h> #include <signal.h> +#include <termios.h> #include <stdio.h> #include <unistd.h> #include <sys/param.h> @@ -237,3 +238,7 @@ type BpfInsn C.struct_bpf_insn type BpfHdr C.struct_bpf_hdr type BpfTimeval C.struct_bpf_timeval + +// Terminal handling + +type Termios C.struct_termios diff --git a/src/pkg/syscall/types_solaris.go b/src/pkg/syscall/types_solaris.go new file mode 100644 index 000000000..53fa35068 --- /dev/null +++ b/src/pkg/syscall/types_solaris.go @@ -0,0 +1,222 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build ignore + +/* +Input to cgo -godefs. See also mkerrors.sh and mkall.sh +*/ + +// +godefs map struct_in_addr [4]byte /* in_addr */ +// +godefs map struct_in6_addr [16]byte /* in6_addr */ + +package syscall + +/* +#define KERNEL +#include <dirent.h> +#include <fcntl.h> +#include <signal.h> +#include <termios.h> +#include <stdio.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/param.h> +#include <sys/resource.h> +#include <sys/select.h> +#include <sys/signal.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/un.h> +#include <sys/wait.h> +#include <net/bpf.h> +#include <net/if.h> +#include <net/if_dl.h> +#include <net/route.h> +#include <netinet/in.h> +#include <netinet/icmp6.h> +#include <netinet/tcp.h> + +enum { + sizeofPtr = sizeof(void*), +}; + +union sockaddr_all { + struct sockaddr s1; // this one gets used for fields + struct sockaddr_in s2; // these pad it out + struct sockaddr_in6 s3; + struct sockaddr_un s4; + struct sockaddr_dl s5; +}; + +struct sockaddr_any { + struct sockaddr addr; + char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)]; +}; + +*/ +import "C" + +// Machine characteristics; for internal use. + +const ( + sizeofPtr = C.sizeofPtr + sizeofShort = C.sizeof_short + sizeofInt = C.sizeof_int + sizeofLong = C.sizeof_long + sizeofLongLong = C.sizeof_longlong +) + +// Basic types + +type ( + _C_short C.short + _C_int C.int + _C_long C.long + _C_long_long C.longlong +) + +// Time + +type Timespec C.struct_timespec + +type Timeval C.struct_timeval + +type Timeval32 C.struct_timeval32 + +// Processes + +type Rusage C.struct_rusage + +type Rlimit C.struct_rlimit + +type _Gid_t C.gid_t + +// Files + +const ( // Directory mode bits + S_IFMT = C.S_IFMT + S_IFIFO = C.S_IFIFO + S_IFCHR = C.S_IFCHR + S_IFDIR = C.S_IFDIR + S_IFBLK = C.S_IFBLK + S_IFREG = C.S_IFREG + S_IFLNK = C.S_IFLNK + S_IFSOCK = C.S_IFSOCK + S_ISUID = C.S_ISUID + S_ISGID = C.S_ISGID + S_ISVTX = C.S_ISVTX + S_IRUSR = C.S_IRUSR + S_IWUSR = C.S_IWUSR + S_IXUSR = C.S_IXUSR +) + +type Stat_t C.struct_stat + +type Flock_t C.struct_flock + +type Dirent C.struct_dirent + +// Sockets + +type RawSockaddrInet4 C.struct_sockaddr_in + +type RawSockaddrInet6 C.struct_sockaddr_in6 + +type RawSockaddrUnix C.struct_sockaddr_un + +type RawSockaddrDatalink C.struct_sockaddr_dl + +type RawSockaddr C.struct_sockaddr + +type RawSockaddrAny C.struct_sockaddr_any + +type _Socklen C.socklen_t + +type Linger C.struct_linger + +type Iovec C.struct_iovec + +type IPMreq C.struct_ip_mreq + +type IPv6Mreq C.struct_ipv6_mreq + +type Msghdr C.struct_msghdr + +type Cmsghdr C.struct_cmsghdr + +type Inet6Pktinfo C.struct_in6_pktinfo + +type IPv6MTUInfo C.struct_ip6_mtuinfo + +type ICMPv6Filter C.struct_icmp6_filter + +const ( + SizeofSockaddrInet4 = C.sizeof_struct_sockaddr_in + SizeofSockaddrInet6 = C.sizeof_struct_sockaddr_in6 + SizeofSockaddrAny = C.sizeof_struct_sockaddr_any + SizeofSockaddrUnix = C.sizeof_struct_sockaddr_un + SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl + SizeofLinger = C.sizeof_struct_linger + SizeofIPMreq = C.sizeof_struct_ip_mreq + SizeofIPv6Mreq = C.sizeof_struct_ipv6_mreq + SizeofMsghdr = C.sizeof_struct_msghdr + SizeofCmsghdr = C.sizeof_struct_cmsghdr + SizeofInet6Pktinfo = C.sizeof_struct_in6_pktinfo + SizeofIPv6MTUInfo = C.sizeof_struct_ip6_mtuinfo + SizeofICMPv6Filter = C.sizeof_struct_icmp6_filter +) + +// Select + +type FdSet C.fd_set + +// Routing and interface messages + +const ( + SizeofIfMsghdr = C.sizeof_struct_if_msghdr + SizeofIfData = C.sizeof_struct_if_data + SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr + SizeofRtMsghdr = C.sizeof_struct_rt_msghdr + SizeofRtMetrics = C.sizeof_struct_rt_metrics +) + +type IfMsghdr C.struct_if_msghdr + +type IfData C.struct_if_data + +type IfaMsghdr C.struct_ifa_msghdr + +type RtMsghdr C.struct_rt_msghdr + +type RtMetrics C.struct_rt_metrics + +// Berkeley packet filter + +const ( + SizeofBpfVersion = C.sizeof_struct_bpf_version + SizeofBpfStat = C.sizeof_struct_bpf_stat + SizeofBpfProgram = C.sizeof_struct_bpf_program + SizeofBpfInsn = C.sizeof_struct_bpf_insn + SizeofBpfHdr = C.sizeof_struct_bpf_hdr +) + +type BpfVersion C.struct_bpf_version + +type BpfStat C.struct_bpf_stat + +type BpfProgram C.struct_bpf_program + +type BpfInsn C.struct_bpf_insn + +type BpfTimeval C.struct_bpf_timeval + +type BpfHdr C.struct_bpf_hdr + +// Terminal handling + +type Termios C.struct_termios diff --git a/src/pkg/syscall/unzip_nacl.go b/src/pkg/syscall/unzip_nacl.go new file mode 100644 index 000000000..5845e44f0 --- /dev/null +++ b/src/pkg/syscall/unzip_nacl.go @@ -0,0 +1,685 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Small in-memory unzip implementation. +// A simplified copy of the pre-Go 1 compress/flate/inflate.go +// and a modified copy of the zip reader in package time. +// (The one in package time does not support decompression; this one does.) + +package syscall + +const ( + maxCodeLen = 16 // max length of Huffman code + maxHist = 32768 // max history required + maxLit = 286 + maxDist = 32 + numCodes = 19 // number of codes in Huffman meta-code +) + +type decompressor struct { + in string // compressed input + out []byte // uncompressed output + b uint32 // input bits, at top of b + nb uint + err bool // invalid input + eof bool // reached EOF + + h1, h2 huffmanDecoder // decoders for literal/length, distance + bits [maxLit + maxDist]int // lengths defining Huffman codes + codebits [numCodes]int +} + +func (f *decompressor) nextBlock() { + for f.nb < 1+2 { + if f.moreBits(); f.err { + return + } + } + f.eof = f.b&1 == 1 + f.b >>= 1 + typ := f.b & 3 + f.b >>= 2 + f.nb -= 1 + 2 + switch typ { + case 0: + f.dataBlock() + case 1: + // compressed, fixed Huffman tables + f.huffmanBlock(&fixedHuffmanDecoder, nil) + case 2: + // compressed, dynamic Huffman tables + if f.readHuffman(); f.err { + break + } + f.huffmanBlock(&f.h1, &f.h2) + default: + // 3 is reserved. + f.err = true + } +} + +// RFC 1951 section 3.2.7. +// Compression with dynamic Huffman codes + +var codeOrder = [...]int{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15} + +func (f *decompressor) readHuffman() { + // HLIT[5], HDIST[5], HCLEN[4]. + for f.nb < 5+5+4 { + if f.moreBits(); f.err { + return + } + } + nlit := int(f.b&0x1F) + 257 + f.b >>= 5 + ndist := int(f.b&0x1F) + 1 + f.b >>= 5 + nclen := int(f.b&0xF) + 4 + f.b >>= 4 + f.nb -= 5 + 5 + 4 + + // (HCLEN+4)*3 bits: code lengths in the magic codeOrder order. + for i := 0; i < nclen; i++ { + for f.nb < 3 { + if f.moreBits(); f.err { + return + } + } + f.codebits[codeOrder[i]] = int(f.b & 0x7) + f.b >>= 3 + f.nb -= 3 + } + for i := nclen; i < len(codeOrder); i++ { + f.codebits[codeOrder[i]] = 0 + } + if !f.h1.init(f.codebits[0:]) { + f.err = true + return + } + + // HLIT + 257 code lengths, HDIST + 1 code lengths, + // using the code length Huffman code. + for i, n := 0, nlit+ndist; i < n; { + x := f.huffSym(&f.h1) + if f.err { + return + } + if x < 16 { + // Actual length. + f.bits[i] = x + i++ + continue + } + // Repeat previous length or zero. + var rep int + var nb uint + var b int + switch x { + default: + f.err = true + return + case 16: + rep = 3 + nb = 2 + if i == 0 { + f.err = true + return + } + b = f.bits[i-1] + case 17: + rep = 3 + nb = 3 + b = 0 + case 18: + rep = 11 + nb = 7 + b = 0 + } + for f.nb < nb { + if f.moreBits(); f.err { + return + } + } + rep += int(f.b & uint32(1<<nb-1)) + f.b >>= nb + f.nb -= nb + if i+rep > n { + f.err = true + return + } + for j := 0; j < rep; j++ { + f.bits[i] = b + i++ + } + } + + if !f.h1.init(f.bits[0:nlit]) || !f.h2.init(f.bits[nlit:nlit+ndist]) { + f.err = true + return + } +} + +// Decode a single Huffman block from f. +// hl and hd are the Huffman states for the lit/length values +// and the distance values, respectively. If hd == nil, using the +// fixed distance encoding associated with fixed Huffman blocks. +func (f *decompressor) huffmanBlock(hl, hd *huffmanDecoder) { + for { + v := f.huffSym(hl) + if f.err { + return + } + var n uint // number of bits extra + var length int + switch { + case v < 256: + f.out = append(f.out, byte(v)) + continue + case v == 256: + // Done with huffman block; read next block. + return + // otherwise, reference to older data + case v < 265: + length = v - (257 - 3) + n = 0 + case v < 269: + length = v*2 - (265*2 - 11) + n = 1 + case v < 273: + length = v*4 - (269*4 - 19) + n = 2 + case v < 277: + length = v*8 - (273*8 - 35) + n = 3 + case v < 281: + length = v*16 - (277*16 - 67) + n = 4 + case v < 285: + length = v*32 - (281*32 - 131) + n = 5 + default: + length = 258 + n = 0 + } + if n > 0 { + for f.nb < n { + if f.moreBits(); f.err { + return + } + } + length += int(f.b & uint32(1<<n-1)) + f.b >>= n + f.nb -= n + } + + var dist int + if hd == nil { + for f.nb < 5 { + if f.moreBits(); f.err { + return + } + } + dist = int(reverseByte[(f.b&0x1F)<<3]) + f.b >>= 5 + f.nb -= 5 + } else { + if dist = f.huffSym(hd); f.err { + return + } + } + + switch { + case dist < 4: + dist++ + case dist >= 30: + f.err = true + return + default: + nb := uint(dist-2) >> 1 + // have 1 bit in bottom of dist, need nb more. + extra := (dist & 1) << nb + for f.nb < nb { + if f.moreBits(); f.err { + return + } + } + extra |= int(f.b & uint32(1<<nb-1)) + f.b >>= nb + f.nb -= nb + dist = 1<<(nb+1) + 1 + extra + } + + // Copy [-dist:-dist+length] into output. + // Encoding can be prescient, so no check on length. + if dist > len(f.out) { + f.err = true + return + } + + p := len(f.out) - dist + for i := 0; i < length; i++ { + f.out = append(f.out, f.out[p]) + p++ + } + } +} + +// Copy a single uncompressed data block from input to output. +func (f *decompressor) dataBlock() { + // Uncompressed. + // Discard current half-byte. + f.nb = 0 + f.b = 0 + + if len(f.in) < 4 { + f.err = true + return + } + + buf := f.in[:4] + f.in = f.in[4:] + n := int(buf[0]) | int(buf[1])<<8 + nn := int(buf[2]) | int(buf[3])<<8 + if uint16(nn) != uint16(^n) { + f.err = true + return + } + + if len(f.in) < n { + f.err = true + return + } + f.out = append(f.out, f.in[:n]...) + f.in = f.in[n:] +} + +func (f *decompressor) moreBits() { + if len(f.in) == 0 { + f.err = true + return + } + c := f.in[0] + f.in = f.in[1:] + f.b |= uint32(c) << f.nb + f.nb += 8 +} + +// Read the next Huffman-encoded symbol from f according to h. +func (f *decompressor) huffSym(h *huffmanDecoder) int { + for n := uint(h.min); n <= uint(h.max); n++ { + lim := h.limit[n] + if lim == -1 { + continue + } + for f.nb < n { + if f.moreBits(); f.err { + return 0 + } + } + v := int(f.b & uint32(1<<n-1)) + v <<= 16 - n + v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8 // reverse bits + if v <= lim { + f.b >>= n + f.nb -= n + return h.codes[v-h.base[n]] + } + } + f.err = true + return 0 +} + +var reverseByte = [256]byte{ + 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, + 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, + 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, + 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, + 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, + 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, + 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, + 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, + 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, + 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, + 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, + 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, + 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, + 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, + 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, + 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, + 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, + 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, + 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, + 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, + 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, + 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, + 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, + 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, + 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, + 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, + 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, + 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, + 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, + 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, + 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, + 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, +} + +// Hard-coded Huffman tables for DEFLATE algorithm. +// See RFC 1951, section 3.2.6. +var fixedHuffmanDecoder = huffmanDecoder{ + 7, 9, + [maxCodeLen + 1]int{7: 23, 199, 511}, + [maxCodeLen + 1]int{7: 0, 24, 224}, + []int{ + // length 7: 256-279 + 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, + + // length 8: 0-143 + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, + + // length 8: 280-287 + 280, 281, 282, 283, 284, 285, 286, 287, + + // length 9: 144-255 + 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, + }, +} + +// Huffman decoder is based on +// J. Brian Connell, ``A Huffman-Shannon-Fano Code,'' +// Proceedings of the IEEE, 61(7) (July 1973), pp 1046-1047. +type huffmanDecoder struct { + // min, max code length + min, max int + + // limit[i] = largest code word of length i + // Given code v of length n, + // need more bits if v > limit[n]. + limit [maxCodeLen + 1]int + + // base[i] = smallest code word of length i - seq number + base [maxCodeLen + 1]int + + // codes[seq number] = output code. + // Given code v of length n, value is + // codes[v - base[n]]. + codes []int +} + +// Initialize Huffman decoding tables from array of code lengths. +func (h *huffmanDecoder) init(bits []int) bool { + // Count number of codes of each length, + // compute min and max length. + var count [maxCodeLen + 1]int + var min, max int + for _, n := range bits { + if n == 0 { + continue + } + if min == 0 || n < min { + min = n + } + if n > max { + max = n + } + count[n]++ + } + if max == 0 { + return false + } + + h.min = min + h.max = max + + // For each code range, compute + // nextcode (first code of that length), + // limit (last code of that length), and + // base (offset from first code to sequence number). + code := 0 + seq := 0 + var nextcode [maxCodeLen]int + for i := min; i <= max; i++ { + n := count[i] + nextcode[i] = code + h.base[i] = code - seq + code += n + seq += n + h.limit[i] = code - 1 + code <<= 1 + } + + // Make array mapping sequence numbers to codes. + if len(h.codes) < len(bits) { + h.codes = make([]int, len(bits)) + } + for i, n := range bits { + if n == 0 { + continue + } + code := nextcode[n] + nextcode[n]++ + seq := code - h.base[n] + h.codes[seq] = i + } + return true +} + +func inflate(in string) (out []byte) { + var d decompressor + d.in = in + for !d.err && !d.eof { + d.nextBlock() + } + if len(d.in) != 0 { + println("fs unzip: junk at end of compressed data") + return nil + } + return d.out +} + +// get4 returns the little-endian 32-bit value in b. +func zget4(b string) int { + if len(b) < 4 { + return 0 + } + return int(b[0]) | int(b[1])<<8 | int(b[2])<<16 | int(b[3])<<24 +} + +// get2 returns the little-endian 16-bit value in b. +func zget2(b string) int { + if len(b) < 2 { + return 0 + } + return int(b[0]) | int(b[1])<<8 +} + +func unzip(data string) { + const ( + zecheader = 0x06054b50 + zcheader = 0x02014b50 + ztailsize = 22 + zheadersize = 30 + zheader = 0x04034b50 + ) + + buf := data[len(data)-ztailsize:] + n := zget2(buf[10:]) + size := zget4(buf[12:]) + off := zget4(buf[16:]) + + hdr := data[off : off+size] + for i := 0; i < n; i++ { + // zip entry layout: + // 0 magic[4] + // 4 madevers[1] + // 5 madeos[1] + // 6 extvers[1] + // 7 extos[1] + // 8 flags[2] + // 10 meth[2] + // 12 modtime[2] + // 14 moddate[2] + // 16 crc[4] + // 20 csize[4] + // 24 uncsize[4] + // 28 namelen[2] + // 30 xlen[2] + // 32 fclen[2] + // 34 disknum[2] + // 36 iattr[2] + // 38 eattr[4] + // 42 off[4] + // 46 name[namelen] + // 46+namelen+xlen+fclen - next header + // + if zget4(hdr) != zcheader { + println("fs unzip: bad magic") + break + } + meth := zget2(hdr[10:]) + mtime := zget2(hdr[12:]) + mdate := zget2(hdr[14:]) + csize := zget4(hdr[20:]) + size := zget4(hdr[24:]) + namelen := zget2(hdr[28:]) + xlen := zget2(hdr[30:]) + fclen := zget2(hdr[32:]) + xattr := uint32(zget4(hdr[38:])) >> 16 + off := zget4(hdr[42:]) + name := hdr[46 : 46+namelen] + hdr = hdr[46+namelen+xlen+fclen:] + + // zip per-file header layout: + // 0 magic[4] + // 4 extvers[1] + // 5 extos[1] + // 6 flags[2] + // 8 meth[2] + // 10 modtime[2] + // 12 moddate[2] + // 14 crc[4] + // 18 csize[4] + // 22 uncsize[4] + // 26 namelen[2] + // 28 xlen[2] + // 30 name[namelen] + // 30+namelen+xlen - file data + // + buf := data[off : off+zheadersize+namelen] + if zget4(buf) != zheader || + zget2(buf[8:]) != meth || + zget2(buf[26:]) != namelen || + buf[30:30+namelen] != name { + println("fs unzip: inconsistent zip file") + return + } + xlen = zget2(buf[28:]) + + off += zheadersize + namelen + xlen + + var fdata []byte + switch meth { + case 0: + // buf is uncompressed + buf = data[off : off+size] + fdata = []byte(buf) + case 8: + // buf is deflate-compressed + buf = data[off : off+csize] + fdata = inflate(buf) + if len(fdata) != size { + println("fs unzip: inconsistent size in zip file") + return + } + } + + if xattr&S_IFMT == 0 { + if xattr&0777 == 0 { + xattr |= 0666 + } + if len(name) > 0 && name[len(name)-1] == '/' { + xattr |= S_IFDIR + xattr |= 0111 + } else { + xattr |= S_IFREG + } + } + + if err := create(name, xattr, zipToTime(mdate, mtime), fdata); err != nil { + print("fs unzip: create ", name, ": ", err.Error(), "\n") + } + } + + chdirEnv() +} + +func zipToTime(date, time int) int64 { + dd := date & 0x1f + mm := date >> 5 & 0xf + yy := date >> 9 // since 1980 + + sec := int64(315532800) // jan 1 1980 + sec += int64(yy) * 365 * 86400 + sec += int64(yy) / 4 * 86400 + if yy%4 > 0 || mm >= 3 { + sec += 86400 + } + sec += int64(daysBeforeMonth[mm]) * 86400 + sec += int64(dd-1) * 86400 + + h := time >> 11 + m := time >> 5 & 0x3F + s := time & 0x1f * 2 + sec += int64(h*3600 + m*60 + s) + + return sec +} + +var daysBeforeMonth = [...]int32{ + 0, + 0, + 31, + 31 + 28, + 31 + 28 + 31, + 31 + 28 + 31 + 30, + 31 + 28 + 31 + 30 + 31, + 31 + 28 + 31 + 30 + 31 + 30, + 31 + 28 + 31 + 30 + 31 + 30 + 31, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30, + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31, +} diff --git a/src/pkg/syscall/zerrors_dragonfly_386.go b/src/pkg/syscall/zerrors_dragonfly_386.go index a2eb926ee..701a1c381 100644 --- a/src/pkg/syscall/zerrors_dragonfly_386.go +++ b/src/pkg/syscall/zerrors_dragonfly_386.go @@ -311,7 +311,10 @@ const ( FD_CLOEXEC = 0x1 FD_SETSIZE = 0x400 FLUSHO = 0x800000 + F_DUP2FD = 0xa + F_DUP2FD_CLOEXEC = 0x12 F_DUPFD = 0x0 + F_DUPFD_CLOEXEC = 0x11 F_GETFD = 0x1 F_GETFL = 0x3 F_GETLK = 0x7 @@ -1475,7 +1478,7 @@ var errors = [...]string{ 90: "multihop attempted", 91: "link has been severed", 92: "protocol error", - 93: "unknown error: 93", + 93: "no medium found", 94: "unknown error: 94", 95: "unknown error: 95", 96: "unknown error: 96", diff --git a/src/pkg/syscall/zerrors_dragonfly_amd64.go b/src/pkg/syscall/zerrors_dragonfly_amd64.go index d2fe97c68..59bff751c 100644 --- a/src/pkg/syscall/zerrors_dragonfly_amd64.go +++ b/src/pkg/syscall/zerrors_dragonfly_amd64.go @@ -311,7 +311,10 @@ const ( FD_CLOEXEC = 0x1 FD_SETSIZE = 0x400 FLUSHO = 0x800000 + F_DUP2FD = 0xa + F_DUP2FD_CLOEXEC = 0x12 F_DUPFD = 0x0 + F_DUPFD_CLOEXEC = 0x11 F_GETFD = 0x1 F_GETFL = 0x3 F_GETLK = 0x7 @@ -1475,7 +1478,7 @@ var errors = [...]string{ 90: "multihop attempted", 91: "link has been severed", 92: "protocol error", - 93: "unknown error: 93", + 93: "no medium found", 94: "unknown error: 94", 95: "unknown error: 95", 96: "unknown error: 96", diff --git a/src/pkg/syscall/zerrors_freebsd_386.go b/src/pkg/syscall/zerrors_freebsd_386.go index 43d7c5969..cd3aa80a9 100644 --- a/src/pkg/syscall/zerrors_freebsd_386.go +++ b/src/pkg/syscall/zerrors_freebsd_386.go @@ -25,13 +25,15 @@ const ( AF_IMPLINK = 0x3 AF_INET = 0x2 AF_INET6 = 0x1c + AF_INET6_SDP = 0x2a + AF_INET_SDP = 0x28 AF_IPX = 0x17 AF_ISDN = 0x1a AF_ISO = 0x7 AF_LAT = 0xe AF_LINK = 0x12 AF_LOCAL = 0x1 - AF_MAX = 0x26 + AF_MAX = 0x2a AF_NATM = 0x1d AF_NETBIOS = 0x6 AF_NETGRAPH = 0x20 @@ -332,10 +334,11 @@ const ( DLT_LINUX_SLL = 0x71 DLT_LOOP = 0x6c DLT_LTALK = 0x72 - DLT_MATCHING_MAX = 0xf2 + DLT_MATCHING_MAX = 0xf6 DLT_MATCHING_MIN = 0x68 DLT_MFR = 0xb6 DLT_MOST = 0xd3 + DLT_MPEG_2_TS = 0xf3 DLT_MPLS = 0xdb DLT_MTP2 = 0x8c DLT_MTP2_WITH_PHDR = 0x8b @@ -343,7 +346,9 @@ const ( DLT_MUX27010 = 0xec DLT_NETANALYZER = 0xf0 DLT_NETANALYZER_TRANSPARENT = 0xf1 + DLT_NFC_LLCP = 0xf5 DLT_NFLOG = 0xef + DLT_NG40 = 0xf4 DLT_NULL = 0x0 DLT_PCI_EXP = 0x7d DLT_PFLOG = 0x75 @@ -423,6 +428,7 @@ const ( EV_DELETE = 0x2 EV_DISABLE = 0x8 EV_DISPATCH = 0x80 + EV_DROP = 0x1000 EV_ENABLE = 0x4 EV_EOF = 0x8000 EV_ERROR = 0x4000 @@ -789,6 +795,7 @@ const ( IPPROTO_MHRP = 0x30 IPPROTO_MICP = 0x5f IPPROTO_MOBILE = 0x37 + IPPROTO_MPLS = 0x89 IPPROTO_MTP = 0x5c IPPROTO_MUX = 0x12 IPPROTO_ND = 0x4d @@ -996,6 +1003,9 @@ const ( MADV_RANDOM = 0x1 MADV_SEQUENTIAL = 0x2 MADV_WILLNEED = 0x3 + MAP_ALIGNED_SUPER = 0x1000000 + MAP_ALIGNMENT_MASK = -0x1000000 + MAP_ALIGNMENT_SHIFT = 0x18 MAP_ANON = 0x1000 MAP_ANONYMOUS = 0x1000 MAP_COPY = 0x2 @@ -1014,6 +1024,7 @@ const ( MAP_STACK = 0x400 MCL_CURRENT = 0x1 MCL_FUTURE = 0x2 + MSG_CMSG_CLOEXEC = 0x40000 MSG_COMPAT = 0x8000 MSG_CTRUNC = 0x20 MSG_DONTROUTE = 0x4 @@ -1030,6 +1041,7 @@ const ( MS_ASYNC = 0x1 MS_INVALIDATE = 0x2 MS_SYNC = 0x0 + NAME_MAX = 0xff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 NET_RT_IFLIST = 0x3 @@ -1069,6 +1081,7 @@ const ( O_ACCMODE = 0x3 O_APPEND = 0x8 O_ASYNC = 0x40 + O_CLOEXEC = 0x100000 O_CREAT = 0x200 O_DIRECT = 0x10000 O_DIRECTORY = 0x20000 @@ -1129,6 +1142,7 @@ const ( RTF_DYNAMIC = 0x10 RTF_FMASK = 0x1004d808 RTF_GATEWAY = 0x2 + RTF_GWFLAG_COMPAT = 0x80000000 RTF_HOST = 0x4 RTF_LLDATA = 0x400 RTF_LLINFO = 0x400 @@ -1177,6 +1191,7 @@ const ( RTV_WEIGHT = 0x100 RT_CACHING_CONTEXT = 0x1 RT_DEFAULT_FIB = 0x0 + RT_NORTREF = 0x2 RUSAGE_CHILDREN = -0x1 RUSAGE_SELF = 0x0 RUSAGE_THREAD = 0x1 @@ -1258,8 +1273,10 @@ const ( SIOCSLIFPHYADDR = 0x8118694a SIOCSLOWAT = 0x80047302 SIOCSPGRP = 0x80047308 + SOCK_CLOEXEC = 0x10000000 SOCK_DGRAM = 0x2 SOCK_MAXADDRLEN = 0xff + SOCK_NONBLOCK = 0x20000000 SOCK_RAW = 0x3 SOCK_RDM = 0x4 SOCK_SEQPACKET = 0x5 @@ -1299,6 +1316,7 @@ const ( SO_TYPE = 0x1008 SO_USELOOPBACK = 0x40 SO_USER_COOKIE = 0x1015 + SO_VENDOR = 0x80000000 TCIFLUSH = 0x1 TCIOFLUSH = 0x3 TCOFLUSH = 0x2 @@ -1322,6 +1340,7 @@ const ( TCP_NODELAY = 0x1 TCP_NOOPT = 0x8 TCP_NOPUSH = 0x4 + TCP_VENDOR = 0x80000000 TCSAFLUSH = 0x2 TIOCCBRK = 0x2000747a TIOCCDTR = 0x20007478 @@ -1407,10 +1426,12 @@ const ( VWERASE = 0x4 WCONTINUED = 0x4 WCOREFLAG = 0x80 + WEXITED = 0x10 WLINUXCLONE = 0x80000000 WNOHANG = 0x1 WNOWAIT = 0x8 WSTOPPED = 0x2 + WTRAPPED = 0x20 WUNTRACED = 0x2 ) @@ -1453,7 +1474,7 @@ const ( EIO = Errno(0x5) EISCONN = Errno(0x38) EISDIR = Errno(0x15) - ELAST = Errno(0x5e) + ELAST = Errno(0x60) ELOOP = Errno(0x3e) EMFILE = Errno(0x18) EMLINK = Errno(0x1f) @@ -1482,12 +1503,14 @@ const ( ENOTCONN = Errno(0x39) ENOTDIR = Errno(0x14) ENOTEMPTY = Errno(0x42) + ENOTRECOVERABLE = Errno(0x5f) ENOTSOCK = Errno(0x26) ENOTSUP = Errno(0x2d) ENOTTY = Errno(0x19) ENXIO = Errno(0x6) EOPNOTSUPP = Errno(0x2d) EOVERFLOW = Errno(0x54) + EOWNERDEAD = Errno(0x60) EPERM = Errno(0x1) EPFNOSUPPORT = Errno(0x2e) EPIPE = Errno(0x20) @@ -1531,6 +1554,7 @@ const ( SIGIO = Signal(0x17) SIGIOT = Signal(0x6) SIGKILL = Signal(0x9) + SIGLIBRT = Signal(0x21) SIGLWP = Signal(0x20) SIGPIPE = Signal(0xd) SIGPROF = Signal(0x1b) @@ -1649,6 +1673,8 @@ var errors = [...]string{ 92: "protocol error", 93: "capabilities insufficient", 94: "not permitted in capability mode", + 95: "state not recoverable", + 96: "previous owner died", } // Signal table @@ -1685,4 +1711,5 @@ var signals = [...]string{ 30: "user defined signal 1", 31: "user defined signal 2", 32: "unknown signal", + 33: "unknown signal", } diff --git a/src/pkg/syscall/zerrors_freebsd_amd64.go b/src/pkg/syscall/zerrors_freebsd_amd64.go index 8e03f45e2..9edce6e2f 100644 --- a/src/pkg/syscall/zerrors_freebsd_amd64.go +++ b/src/pkg/syscall/zerrors_freebsd_amd64.go @@ -25,13 +25,15 @@ const ( AF_IMPLINK = 0x3 AF_INET = 0x2 AF_INET6 = 0x1c + AF_INET6_SDP = 0x2a + AF_INET_SDP = 0x28 AF_IPX = 0x17 AF_ISDN = 0x1a AF_ISO = 0x7 AF_LAT = 0xe AF_LINK = 0x12 AF_LOCAL = 0x1 - AF_MAX = 0x26 + AF_MAX = 0x2a AF_NATM = 0x1d AF_NETBIOS = 0x6 AF_NETGRAPH = 0x20 @@ -332,10 +334,11 @@ const ( DLT_LINUX_SLL = 0x71 DLT_LOOP = 0x6c DLT_LTALK = 0x72 - DLT_MATCHING_MAX = 0xf2 + DLT_MATCHING_MAX = 0xf6 DLT_MATCHING_MIN = 0x68 DLT_MFR = 0xb6 DLT_MOST = 0xd3 + DLT_MPEG_2_TS = 0xf3 DLT_MPLS = 0xdb DLT_MTP2 = 0x8c DLT_MTP2_WITH_PHDR = 0x8b @@ -343,7 +346,9 @@ const ( DLT_MUX27010 = 0xec DLT_NETANALYZER = 0xf0 DLT_NETANALYZER_TRANSPARENT = 0xf1 + DLT_NFC_LLCP = 0xf5 DLT_NFLOG = 0xef + DLT_NG40 = 0xf4 DLT_NULL = 0x0 DLT_PCI_EXP = 0x7d DLT_PFLOG = 0x75 @@ -423,6 +428,7 @@ const ( EV_DELETE = 0x2 EV_DISABLE = 0x8 EV_DISPATCH = 0x80 + EV_DROP = 0x1000 EV_ENABLE = 0x4 EV_EOF = 0x8000 EV_ERROR = 0x4000 @@ -789,6 +795,7 @@ const ( IPPROTO_MHRP = 0x30 IPPROTO_MICP = 0x5f IPPROTO_MOBILE = 0x37 + IPPROTO_MPLS = 0x89 IPPROTO_MTP = 0x5c IPPROTO_MUX = 0x12 IPPROTO_ND = 0x4d @@ -996,6 +1003,10 @@ const ( MADV_RANDOM = 0x1 MADV_SEQUENTIAL = 0x2 MADV_WILLNEED = 0x3 + MAP_32BIT = 0x80000 + MAP_ALIGNED_SUPER = 0x1000000 + MAP_ALIGNMENT_MASK = -0x1000000 + MAP_ALIGNMENT_SHIFT = 0x18 MAP_ANON = 0x1000 MAP_ANONYMOUS = 0x1000 MAP_COPY = 0x2 @@ -1014,6 +1025,7 @@ const ( MAP_STACK = 0x400 MCL_CURRENT = 0x1 MCL_FUTURE = 0x2 + MSG_CMSG_CLOEXEC = 0x40000 MSG_COMPAT = 0x8000 MSG_CTRUNC = 0x20 MSG_DONTROUTE = 0x4 @@ -1030,6 +1042,7 @@ const ( MS_ASYNC = 0x1 MS_INVALIDATE = 0x2 MS_SYNC = 0x0 + NAME_MAX = 0xff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 NET_RT_IFLIST = 0x3 @@ -1069,6 +1082,7 @@ const ( O_ACCMODE = 0x3 O_APPEND = 0x8 O_ASYNC = 0x40 + O_CLOEXEC = 0x100000 O_CREAT = 0x200 O_DIRECT = 0x10000 O_DIRECTORY = 0x20000 @@ -1129,6 +1143,7 @@ const ( RTF_DYNAMIC = 0x10 RTF_FMASK = 0x1004d808 RTF_GATEWAY = 0x2 + RTF_GWFLAG_COMPAT = 0x80000000 RTF_HOST = 0x4 RTF_LLDATA = 0x400 RTF_LLINFO = 0x400 @@ -1177,6 +1192,7 @@ const ( RTV_WEIGHT = 0x100 RT_CACHING_CONTEXT = 0x1 RT_DEFAULT_FIB = 0x0 + RT_NORTREF = 0x2 RUSAGE_CHILDREN = -0x1 RUSAGE_SELF = 0x0 RUSAGE_THREAD = 0x1 @@ -1258,8 +1274,10 @@ const ( SIOCSLIFPHYADDR = 0x8118694a SIOCSLOWAT = 0x80047302 SIOCSPGRP = 0x80047308 + SOCK_CLOEXEC = 0x10000000 SOCK_DGRAM = 0x2 SOCK_MAXADDRLEN = 0xff + SOCK_NONBLOCK = 0x20000000 SOCK_RAW = 0x3 SOCK_RDM = 0x4 SOCK_SEQPACKET = 0x5 @@ -1299,6 +1317,7 @@ const ( SO_TYPE = 0x1008 SO_USELOOPBACK = 0x40 SO_USER_COOKIE = 0x1015 + SO_VENDOR = 0x80000000 TCIFLUSH = 0x1 TCIOFLUSH = 0x3 TCOFLUSH = 0x2 @@ -1322,6 +1341,7 @@ const ( TCP_NODELAY = 0x1 TCP_NOOPT = 0x8 TCP_NOPUSH = 0x4 + TCP_VENDOR = 0x80000000 TCSAFLUSH = 0x2 TIOCCBRK = 0x2000747a TIOCCDTR = 0x20007478 @@ -1407,10 +1427,12 @@ const ( VWERASE = 0x4 WCONTINUED = 0x4 WCOREFLAG = 0x80 + WEXITED = 0x10 WLINUXCLONE = 0x80000000 WNOHANG = 0x1 WNOWAIT = 0x8 WSTOPPED = 0x2 + WTRAPPED = 0x20 WUNTRACED = 0x2 ) @@ -1453,7 +1475,7 @@ const ( EIO = Errno(0x5) EISCONN = Errno(0x38) EISDIR = Errno(0x15) - ELAST = Errno(0x5e) + ELAST = Errno(0x60) ELOOP = Errno(0x3e) EMFILE = Errno(0x18) EMLINK = Errno(0x1f) @@ -1482,12 +1504,14 @@ const ( ENOTCONN = Errno(0x39) ENOTDIR = Errno(0x14) ENOTEMPTY = Errno(0x42) + ENOTRECOVERABLE = Errno(0x5f) ENOTSOCK = Errno(0x26) ENOTSUP = Errno(0x2d) ENOTTY = Errno(0x19) ENXIO = Errno(0x6) EOPNOTSUPP = Errno(0x2d) EOVERFLOW = Errno(0x54) + EOWNERDEAD = Errno(0x60) EPERM = Errno(0x1) EPFNOSUPPORT = Errno(0x2e) EPIPE = Errno(0x20) @@ -1531,6 +1555,7 @@ const ( SIGIO = Signal(0x17) SIGIOT = Signal(0x6) SIGKILL = Signal(0x9) + SIGLIBRT = Signal(0x21) SIGLWP = Signal(0x20) SIGPIPE = Signal(0xd) SIGPROF = Signal(0x1b) @@ -1649,6 +1674,8 @@ var errors = [...]string{ 92: "protocol error", 93: "capabilities insufficient", 94: "not permitted in capability mode", + 95: "state not recoverable", + 96: "previous owner died", } // Signal table @@ -1685,4 +1712,5 @@ var signals = [...]string{ 30: "user defined signal 1", 31: "user defined signal 2", 32: "unknown signal", + 33: "unknown signal", } diff --git a/src/pkg/syscall/zerrors_freebsd_arm.go b/src/pkg/syscall/zerrors_freebsd_arm.go index 269f179b3..f29dd057b 100644 --- a/src/pkg/syscall/zerrors_freebsd_arm.go +++ b/src/pkg/syscall/zerrors_freebsd_arm.go @@ -25,13 +25,15 @@ const ( AF_IMPLINK = 0x3 AF_INET = 0x2 AF_INET6 = 0x1c + AF_INET6_SDP = 0x2a + AF_INET_SDP = 0x28 AF_IPX = 0x17 AF_ISDN = 0x1a AF_ISO = 0x7 AF_LAT = 0xe AF_LINK = 0x12 AF_LOCAL = 0x1 - AF_MAX = 0x26 + AF_MAX = 0x2a AF_NATM = 0x1d AF_NETBIOS = 0x6 AF_NETGRAPH = 0x20 @@ -128,7 +130,7 @@ const ( BIOCGETZMAX = 0x4004427f BIOCGHDRCMPLT = 0x40044274 BIOCGRSIG = 0x40044272 - BIOCGRTIMEOUT = 0x400c426e + BIOCGRTIMEOUT = 0x4010426e BIOCGSEESENT = 0x40044276 BIOCGSTATS = 0x4008426f BIOCGTSTAMP = 0x40044283 @@ -147,7 +149,7 @@ const ( BIOCSETZBUF = 0x800c4281 BIOCSHDRCMPLT = 0x80044275 BIOCSRSIG = 0x80044273 - BIOCSRTIMEOUT = 0x800c426d + BIOCSRTIMEOUT = 0x8010426d BIOCSSEESENT = 0x80044277 BIOCSTSTAMP = 0x80044284 BIOCVERSION = 0x40044271 @@ -426,6 +428,7 @@ const ( EV_DELETE = 0x2 EV_DISABLE = 0x8 EV_DISPATCH = 0x80 + EV_DROP = 0x1000 EV_ENABLE = 0x4 EV_EOF = 0x8000 EV_ERROR = 0x4000 @@ -521,6 +524,7 @@ const ( IFT_BGPPOLICYACCOUNTING = 0xa2 IFT_BRIDGE = 0xd1 IFT_BSC = 0x53 + IFT_CARP = 0xf8 IFT_CCTEMUL = 0x3d IFT_CEPT = 0x13 IFT_CES = 0x85 @@ -999,6 +1003,9 @@ const ( MADV_RANDOM = 0x1 MADV_SEQUENTIAL = 0x2 MADV_WILLNEED = 0x3 + MAP_ALIGNED_SUPER = 0x1000000 + MAP_ALIGNMENT_MASK = -0x1000000 + MAP_ALIGNMENT_SHIFT = 0x18 MAP_ANON = 0x1000 MAP_ANONYMOUS = 0x1000 MAP_COPY = 0x2 @@ -1017,6 +1024,7 @@ const ( MAP_STACK = 0x400 MCL_CURRENT = 0x1 MCL_FUTURE = 0x2 + MSG_CMSG_CLOEXEC = 0x40000 MSG_COMPAT = 0x8000 MSG_CTRUNC = 0x20 MSG_DONTROUTE = 0x4 @@ -1033,6 +1041,7 @@ const ( MS_ASYNC = 0x1 MS_INVALIDATE = 0x2 MS_SYNC = 0x0 + NAME_MAX = 0xff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 NET_RT_IFLIST = 0x3 @@ -1072,6 +1081,7 @@ const ( O_ACCMODE = 0x3 O_APPEND = 0x8 O_ASYNC = 0x40 + O_CLOEXEC = 0x100000 O_CREAT = 0x200 O_DIRECT = 0x10000 O_DIRECTORY = 0x20000 @@ -1132,6 +1142,7 @@ const ( RTF_DYNAMIC = 0x10 RTF_FMASK = 0x1004d808 RTF_GATEWAY = 0x2 + RTF_GWFLAG_COMPAT = 0x80000000 RTF_HOST = 0x4 RTF_LLDATA = 0x400 RTF_LLINFO = 0x400 @@ -1193,7 +1204,7 @@ const ( SHUT_WR = 0x1 SIOCADDMULTI = 0x80206931 SIOCADDRT = 0x8030720a - SIOCAIFADDR = 0x8044692b + SIOCAIFADDR = 0x8040691a SIOCAIFGROUP = 0x80246987 SIOCALIFADDR = 0x8118691b SIOCATMARK = 0x40047307 @@ -1227,7 +1238,7 @@ const ( SIOCGIFPDSTADDR = 0xc0206948 SIOCGIFPHYS = 0xc0206935 SIOCGIFPSRCADDR = 0xc0206947 - SIOCGIFSTATUS = 0xc334693b + SIOCGIFSTATUS = 0xc331693b SIOCGLIFADDR = 0xc118691c SIOCGLIFPHYADDR = 0xc118694b SIOCGLOWAT = 0x40047303 @@ -1255,15 +1266,17 @@ const ( SIOCSIFMTU = 0x80206934 SIOCSIFNAME = 0x80206928 SIOCSIFNETMASK = 0x80206916 - SIOCSIFPHYADDR = 0x80446946 + SIOCSIFPHYADDR = 0x80406946 SIOCSIFPHYS = 0x80206936 SIOCSIFRVNET = 0xc020695b SIOCSIFVNET = 0xc020695a SIOCSLIFPHYADDR = 0x8118694a SIOCSLOWAT = 0x80047302 SIOCSPGRP = 0x80047308 + SOCK_CLOEXEC = 0x10000000 SOCK_DGRAM = 0x2 SOCK_MAXADDRLEN = 0xff + SOCK_NONBLOCK = 0x20000000 SOCK_RAW = 0x3 SOCK_RDM = 0x4 SOCK_SEQPACKET = 0x5 @@ -1303,6 +1316,7 @@ const ( SO_TYPE = 0x1008 SO_USELOOPBACK = 0x40 SO_USER_COOKIE = 0x1015 + SO_VENDOR = 0x80000000 TCIFLUSH = 0x1 TCIOFLUSH = 0x3 TCOFLUSH = 0x2 @@ -1326,6 +1340,7 @@ const ( TCP_NODELAY = 0x1 TCP_NOOPT = 0x8 TCP_NOPUSH = 0x4 + TCP_VENDOR = 0x80000000 TCSAFLUSH = 0x2 TIOCCBRK = 0x2000747a TIOCCDTR = 0x20007478 @@ -1387,7 +1402,7 @@ const ( TIOCSTI = 0x80017472 TIOCSTOP = 0x2000746f TIOCSWINSZ = 0x80087467 - TIOCTIMESTAMP = 0x400c7459 + TIOCTIMESTAMP = 0x40107459 TIOCUCNTL = 0x80047466 TOSTOP = 0x400000 VDISCARD = 0xf @@ -1459,7 +1474,7 @@ const ( EIO = Errno(0x5) EISCONN = Errno(0x38) EISDIR = Errno(0x15) - ELAST = Errno(0x5e) + ELAST = Errno(0x60) ELOOP = Errno(0x3e) EMFILE = Errno(0x18) EMLINK = Errno(0x1f) @@ -1488,12 +1503,14 @@ const ( ENOTCONN = Errno(0x39) ENOTDIR = Errno(0x14) ENOTEMPTY = Errno(0x42) + ENOTRECOVERABLE = Errno(0x5f) ENOTSOCK = Errno(0x26) ENOTSUP = Errno(0x2d) ENOTTY = Errno(0x19) ENXIO = Errno(0x6) EOPNOTSUPP = Errno(0x2d) EOVERFLOW = Errno(0x54) + EOWNERDEAD = Errno(0x60) EPERM = Errno(0x1) EPFNOSUPPORT = Errno(0x2e) EPIPE = Errno(0x20) @@ -1656,6 +1673,8 @@ var errors = [...]string{ 92: "protocol error", 93: "capabilities insufficient", 94: "not permitted in capability mode", + 95: "state not recoverable", + 96: "previous owner died", } // Signal table diff --git a/src/pkg/syscall/zerrors_netbsd_386.go b/src/pkg/syscall/zerrors_netbsd_386.go index 9b93f5a15..1e3dff7fa 100644 --- a/src/pkg/syscall/zerrors_netbsd_386.go +++ b/src/pkg/syscall/zerrors_netbsd_386.go @@ -146,6 +146,14 @@ const ( BRKINT = 0x2 CFLUSH = 0xf CLOCAL = 0x8000 + CLONE_CSIGNAL = 0xff + CLONE_FILES = 0x400 + CLONE_FS = 0x200 + CLONE_PID = 0x1000 + CLONE_PTRACE = 0x2000 + CLONE_SIGHAND = 0x800 + CLONE_VFORK = 0x4000 + CLONE_VM = 0x100 CREAD = 0x800 CS5 = 0x0 CS6 = 0x100 @@ -962,6 +970,40 @@ const ( LOCK_NB = 0x4 LOCK_SH = 0x1 LOCK_UN = 0x8 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x6 + MADV_NORMAL = 0x0 + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_SPACEAVAIL = 0x5 + MADV_WILLNEED = 0x3 + MAP_ALIGNMENT_16MB = 0x18000000 + MAP_ALIGNMENT_1TB = 0x28000000 + MAP_ALIGNMENT_256TB = 0x30000000 + MAP_ALIGNMENT_4GB = 0x20000000 + MAP_ALIGNMENT_64KB = 0x10000000 + MAP_ALIGNMENT_64PB = 0x38000000 + MAP_ALIGNMENT_MASK = -0x1000000 + MAP_ALIGNMENT_SHIFT = 0x18 + MAP_ANON = 0x1000 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_HASSEMAPHORE = 0x200 + MAP_INHERIT = 0x80 + MAP_INHERIT_COPY = 0x1 + MAP_INHERIT_DEFAULT = 0x1 + MAP_INHERIT_DONATE_COPY = 0x3 + MAP_INHERIT_NONE = 0x2 + MAP_INHERIT_SHARE = 0x0 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_SHARED = 0x1 + MAP_STACK = 0x2000 + MAP_TRYFIXED = 0x400 + MAP_WIRED = 0x800 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 MSG_BCAST = 0x100 MSG_CMSG_CLOEXEC = 0x800 MSG_CONTROLMBUF = 0x2000000 @@ -980,6 +1022,9 @@ const ( MSG_TRUNC = 0x10 MSG_USERFLAGS = 0xffffff MSG_WAITALL = 0x40 + MS_ASYNC = 0x1 + MS_INVALIDATE = 0x2 + MS_SYNC = 0x4 NAME_MAX = 0x1ff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 @@ -1039,10 +1084,14 @@ const ( PARMRK = 0x8 PARODD = 0x2000 PENDIN = 0x20000000 - PRI_IOFLUSH = 0x7c PRIO_PGRP = 0x1 PRIO_PROCESS = 0x0 PRIO_USER = 0x2 + PRI_IOFLUSH = 0x7c + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 RLIMIT_AS = 0xa RLIMIT_CORE = 0x4 RLIMIT_CPU = 0x0 diff --git a/src/pkg/syscall/zerrors_netbsd_amd64.go b/src/pkg/syscall/zerrors_netbsd_amd64.go index 4db30fa5c..1469d00b7 100644 --- a/src/pkg/syscall/zerrors_netbsd_amd64.go +++ b/src/pkg/syscall/zerrors_netbsd_amd64.go @@ -146,6 +146,14 @@ const ( BRKINT = 0x2 CFLUSH = 0xf CLOCAL = 0x8000 + CLONE_CSIGNAL = 0xff + CLONE_FILES = 0x400 + CLONE_FS = 0x200 + CLONE_PID = 0x1000 + CLONE_PTRACE = 0x2000 + CLONE_SIGHAND = 0x800 + CLONE_VFORK = 0x4000 + CLONE_VM = 0x100 CREAD = 0x800 CS5 = 0x0 CS6 = 0x100 @@ -952,6 +960,40 @@ const ( LOCK_NB = 0x4 LOCK_SH = 0x1 LOCK_UN = 0x8 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x6 + MADV_NORMAL = 0x0 + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_SPACEAVAIL = 0x5 + MADV_WILLNEED = 0x3 + MAP_ALIGNMENT_16MB = 0x18000000 + MAP_ALIGNMENT_1TB = 0x28000000 + MAP_ALIGNMENT_256TB = 0x30000000 + MAP_ALIGNMENT_4GB = 0x20000000 + MAP_ALIGNMENT_64KB = 0x10000000 + MAP_ALIGNMENT_64PB = 0x38000000 + MAP_ALIGNMENT_MASK = -0x1000000 + MAP_ALIGNMENT_SHIFT = 0x18 + MAP_ANON = 0x1000 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_HASSEMAPHORE = 0x200 + MAP_INHERIT = 0x80 + MAP_INHERIT_COPY = 0x1 + MAP_INHERIT_DEFAULT = 0x1 + MAP_INHERIT_DONATE_COPY = 0x3 + MAP_INHERIT_NONE = 0x2 + MAP_INHERIT_SHARE = 0x0 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_SHARED = 0x1 + MAP_STACK = 0x2000 + MAP_TRYFIXED = 0x400 + MAP_WIRED = 0x800 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 MSG_BCAST = 0x100 MSG_CMSG_CLOEXEC = 0x800 MSG_CONTROLMBUF = 0x2000000 @@ -970,6 +1012,9 @@ const ( MSG_TRUNC = 0x10 MSG_USERFLAGS = 0xffffff MSG_WAITALL = 0x40 + MS_ASYNC = 0x1 + MS_INVALIDATE = 0x2 + MS_SYNC = 0x4 NAME_MAX = 0x1ff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 @@ -1029,10 +1074,14 @@ const ( PARMRK = 0x8 PARODD = 0x2000 PENDIN = 0x20000000 - PRI_IOFLUSH = 0x7c PRIO_PGRP = 0x1 PRIO_PROCESS = 0x0 PRIO_USER = 0x2 + PRI_IOFLUSH = 0x7c + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 RLIMIT_AS = 0xa RLIMIT_CORE = 0x4 RLIMIT_CPU = 0x0 diff --git a/src/pkg/syscall/zerrors_netbsd_arm.go b/src/pkg/syscall/zerrors_netbsd_arm.go index 9262d5afb..1a88c0d22 100644 --- a/src/pkg/syscall/zerrors_netbsd_arm.go +++ b/src/pkg/syscall/zerrors_netbsd_arm.go @@ -952,6 +952,38 @@ const ( LOCK_NB = 0x4 LOCK_SH = 0x1 LOCK_UN = 0x8 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x6 + MADV_NORMAL = 0x0 + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_SPACEAVAIL = 0x5 + MADV_WILLNEED = 0x3 + MAP_ALIGNMENT_16MB = 0x18000000 + MAP_ALIGNMENT_1TB = 0x28000000 + MAP_ALIGNMENT_256TB = 0x30000000 + MAP_ALIGNMENT_4GB = 0x20000000 + MAP_ALIGNMENT_64KB = 0x10000000 + MAP_ALIGNMENT_64PB = 0x38000000 + MAP_ALIGNMENT_MASK = -0x1000000 + MAP_ALIGNMENT_SHIFT = 0x18 + MAP_ANON = 0x1000 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_HASSEMAPHORE = 0x200 + MAP_INHERIT = 0x80 + MAP_INHERIT_COPY = 0x1 + MAP_INHERIT_DEFAULT = 0x1 + MAP_INHERIT_DONATE_COPY = 0x3 + MAP_INHERIT_NONE = 0x2 + MAP_INHERIT_SHARE = 0x0 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_SHARED = 0x1 + MAP_STACK = 0x2000 + MAP_TRYFIXED = 0x400 + MAP_WIRED = 0x800 MSG_BCAST = 0x100 MSG_CMSG_CLOEXEC = 0x800 MSG_CONTROLMBUF = 0x2000000 @@ -1029,6 +1061,10 @@ const ( PARMRK = 0x8 PARODD = 0x2000 PENDIN = 0x20000000 + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 PRI_IOFLUSH = 0x7c PRIO_PGRP = 0x1 PRIO_PROCESS = 0x0 diff --git a/src/pkg/syscall/zerrors_openbsd_386.go b/src/pkg/syscall/zerrors_openbsd_386.go index e546243b0..082983494 100644 --- a/src/pkg/syscall/zerrors_openbsd_386.go +++ b/src/pkg/syscall/zerrors_openbsd_386.go @@ -77,7 +77,7 @@ const ( BIOCGFILDROP = 0x40044278 BIOCGHDRCMPLT = 0x40044274 BIOCGRSIG = 0x40044273 - BIOCGRTIMEOUT = 0x4008426e + BIOCGRTIMEOUT = 0x400c426e BIOCGSTATS = 0x4008426f BIOCIMMEDIATE = 0x80044270 BIOCLOCK = 0x20004276 @@ -91,7 +91,7 @@ const ( BIOCSFILDROP = 0x80044279 BIOCSHDRCMPLT = 0x80044275 BIOCSRSIG = 0x80044272 - BIOCSRTIMEOUT = 0x8008426d + BIOCSRTIMEOUT = 0x800c426d BIOCVERSION = 0x40044271 BPF_A = 0x10 BPF_ABS = 0x20 @@ -713,6 +713,8 @@ const ( IPPROTO_AH = 0x33 IPPROTO_CARP = 0x70 IPPROTO_DIVERT = 0x102 + IPPROTO_DIVERT_INIT = 0x2 + IPPROTO_DIVERT_RESP = 0x1 IPPROTO_DONE = 0x101 IPPROTO_DSTOPTS = 0x3c IPPROTO_EGP = 0x8 @@ -783,6 +785,7 @@ const ( IPV6_PORTRANGE_HIGH = 0x1 IPV6_PORTRANGE_LOW = 0x2 IPV6_RECVDSTOPTS = 0x28 + IPV6_RECVDSTPORT = 0x40 IPV6_RECVHOPLIMIT = 0x25 IPV6_RECVHOPOPTS = 0x27 IPV6_RECVPATHMTU = 0x2b @@ -807,6 +810,7 @@ const ( IP_DEFAULT_MULTICAST_LOOP = 0x1 IP_DEFAULT_MULTICAST_TTL = 0x1 IP_DF = 0x4000 + IP_DIVERTFL = 0x1022 IP_DROP_MEMBERSHIP = 0xd IP_ESP_NETWORK_LEVEL = 0x16 IP_ESP_TRANS_LEVEL = 0x15 @@ -857,6 +861,32 @@ const ( LOCK_NB = 0x4 LOCK_SH = 0x1 LOCK_UN = 0x8 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x6 + MADV_NORMAL = 0x0 + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_SPACEAVAIL = 0x5 + MADV_WILLNEED = 0x3 + MAP_ANON = 0x1000 + MAP_COPY = 0x4 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_FLAGMASK = 0x1ff7 + MAP_HASSEMAPHORE = 0x200 + MAP_INHERIT = 0x80 + MAP_INHERIT_COPY = 0x1 + MAP_INHERIT_DONATE_COPY = 0x3 + MAP_INHERIT_NONE = 0x2 + MAP_INHERIT_SHARE = 0x0 + MAP_NOEXTEND = 0x100 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_SHARED = 0x1 + MAP_TRYFIXED = 0x400 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 MSG_BCAST = 0x100 MSG_CTRUNC = 0x20 MSG_DONTROUTE = 0x4 @@ -868,6 +898,9 @@ const ( MSG_PEEK = 0x2 MSG_TRUNC = 0x10 MSG_WAITALL = 0x40 + MS_ASYNC = 0x1 + MS_INVALIDATE = 0x4 + MS_SYNC = 0x2 NAME_MAX = 0xff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 @@ -926,10 +959,14 @@ const ( PARODD = 0x2000 PENDIN = 0x20000000 PF_FLUSH = 0x1 - PT_MASK = 0x3ff000 PRIO_PGRP = 0x1 PRIO_PROCESS = 0x0 PRIO_USER = 0x2 + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 + PT_MASK = 0x3ff000 RLIMIT_CORE = 0x4 RLIMIT_CPU = 0x0 RLIMIT_DATA = 0x2 @@ -966,7 +1003,7 @@ const ( RTF_CLONING = 0x100 RTF_DONE = 0x40 RTF_DYNAMIC = 0x10 - RTF_FMASK = 0xf808 + RTF_FMASK = 0x10f808 RTF_GATEWAY = 0x2 RTF_HOST = 0x4 RTF_LLINFO = 0x400 @@ -1001,7 +1038,7 @@ const ( RTM_REDIRECT = 0x6 RTM_RESOLVE = 0xb RTM_RTTUNIT = 0xf4240 - RTM_VERSION = 0x4 + RTM_VERSION = 0x5 RTV_EXPIRE = 0x4 RTV_HOPCOUNT = 0x2 RTV_MTU = 0x1 @@ -1027,7 +1064,7 @@ const ( SIOCBRDGADD = 0x8054693c SIOCBRDGADDS = 0x80546941 SIOCBRDGARL = 0x806e694d - SIOCBRDGDADDR = 0x80286947 + SIOCBRDGDADDR = 0x81286947 SIOCBRDGDEL = 0x8054693d SIOCBRDGDELS = 0x80546942 SIOCBRDGFLUSH = 0x80546948 @@ -1037,14 +1074,14 @@ const ( SIOCBRDGGHT = 0xc0146951 SIOCBRDGGIFFLGS = 0xc054693e SIOCBRDGGMA = 0xc0146953 - SIOCBRDGGPARAM = 0xc0386958 + SIOCBRDGGPARAM = 0xc03c6958 SIOCBRDGGPRI = 0xc0146950 SIOCBRDGGRL = 0xc028694f SIOCBRDGGSIFS = 0xc054693c SIOCBRDGGTO = 0xc0146946 SIOCBRDGIFS = 0xc0546942 SIOCBRDGRTS = 0xc0186943 - SIOCBRDGSADDR = 0xc0286944 + SIOCBRDGSADDR = 0xc1286944 SIOCBRDGSCACHE = 0x80146940 SIOCBRDGSFD = 0x80146952 SIOCBRDGSHT = 0x80146951 @@ -1067,6 +1104,7 @@ const ( SIOCGETPFSYNC = 0xc02069f8 SIOCGETSGCNT = 0xc0147534 SIOCGETVIFCNT = 0xc0147533 + SIOCGETVLAN = 0xc0206990 SIOCGHIWAT = 0x40047301 SIOCGIFADDR = 0xc0206921 SIOCGIFASYNCMAP = 0xc020697c @@ -1080,6 +1118,7 @@ const ( SIOCGIFGENERIC = 0xc020693a SIOCGIFGMEMB = 0xc024698a SIOCGIFGROUP = 0xc0246988 + SIOCGIFHARDMTU = 0xc02069a5 SIOCGIFMEDIA = 0xc0286936 SIOCGIFMETRIC = 0xc0206917 SIOCGIFMTU = 0xc020697e @@ -1094,9 +1133,12 @@ const ( SIOCGLIFADDR = 0xc218691d SIOCGLIFPHYADDR = 0xc218694b SIOCGLIFPHYRTABLE = 0xc02069a2 + SIOCGLIFPHYTTL = 0xc02069a9 SIOCGLOWAT = 0x40047303 SIOCGPGRP = 0x40047309 + SIOCGSPPPPARAMS = 0xc0206994 SIOCGVH = 0xc02069f6 + SIOCGVNETID = 0xc02069a7 SIOCIFCREATE = 0x8020697a SIOCIFDESTROY = 0x80206979 SIOCIFGCLONERS = 0xc00c6978 @@ -1104,6 +1146,7 @@ const ( SIOCSETLABEL = 0x80206999 SIOCSETPFLOW = 0x802069fd SIOCSETPFSYNC = 0x802069f7 + SIOCSETVLAN = 0x8020698f SIOCSHIWAT = 0x80047300 SIOCSIFADDR = 0x8020690c SIOCSIFASYNCMAP = 0x8020697d @@ -1126,9 +1169,12 @@ const ( SIOCSIFXFLAGS = 0x8020699d SIOCSLIFPHYADDR = 0x8218694a SIOCSLIFPHYRTABLE = 0x802069a1 + SIOCSLIFPHYTTL = 0x802069a8 SIOCSLOWAT = 0x80047302 SIOCSPGRP = 0x80047308 + SIOCSSPPPPARAMS = 0x80206993 SIOCSVH = 0xc02069f5 + SIOCSVNETID = 0x802069a6 SOCK_DGRAM = 0x2 SOCK_RAW = 0x3 SOCK_RDM = 0x4 @@ -1171,6 +1217,7 @@ const ( TCP_MD5SIG = 0x4 TCP_MSS = 0x200 TCP_NODELAY = 0x1 + TCP_NOPUSH = 0x10 TCP_NSTATES = 0xb TCP_SACK_ENABLE = 0x8 TCSAFLUSH = 0x2 @@ -1190,7 +1237,8 @@ const ( TIOCGETD = 0x4004741a TIOCGFLAGS = 0x4004745d TIOCGPGRP = 0x40047477 - TIOCGTSTAMP = 0x4008745b + TIOCGSID = 0x40047463 + TIOCGTSTAMP = 0x400c745b TIOCGWINSZ = 0x40087468 TIOCMBIC = 0x8004746b TIOCMBIS = 0x8004746c diff --git a/src/pkg/syscall/zerrors_openbsd_amd64.go b/src/pkg/syscall/zerrors_openbsd_amd64.go index 411b51a68..e9fa37cde 100644 --- a/src/pkg/syscall/zerrors_openbsd_amd64.go +++ b/src/pkg/syscall/zerrors_openbsd_amd64.go @@ -140,10 +140,8 @@ const ( BPF_W = 0x0 BPF_X = 0x8 BRKINT = 0x2 - CCR0_FLUSH = 0x10 CFLUSH = 0xf CLOCAL = 0x8000 - CPUID_CFLUSH = 0x80000 CREAD = 0x800 CS5 = 0x0 CS6 = 0x100 @@ -198,10 +196,6 @@ const ( ECHOKE = 0x1 ECHONL = 0x10 ECHOPRT = 0x20 - EFER_LMA = 0x400 - EFER_LME = 0x100 - EFER_NXE = 0x800 - EFER_SCE = 0x1 EMT_TAGOVF = 0x1 EMUL_ENABLED = 0x1 EMUL_NATIVE = 0x2 @@ -719,6 +713,8 @@ const ( IPPROTO_AH = 0x33 IPPROTO_CARP = 0x70 IPPROTO_DIVERT = 0x102 + IPPROTO_DIVERT_INIT = 0x2 + IPPROTO_DIVERT_RESP = 0x1 IPPROTO_DONE = 0x101 IPPROTO_DSTOPTS = 0x3c IPPROTO_EGP = 0x8 @@ -789,6 +785,7 @@ const ( IPV6_PORTRANGE_HIGH = 0x1 IPV6_PORTRANGE_LOW = 0x2 IPV6_RECVDSTOPTS = 0x28 + IPV6_RECVDSTPORT = 0x40 IPV6_RECVHOPLIMIT = 0x25 IPV6_RECVHOPOPTS = 0x27 IPV6_RECVPATHMTU = 0x2b @@ -813,6 +810,7 @@ const ( IP_DEFAULT_MULTICAST_LOOP = 0x1 IP_DEFAULT_MULTICAST_TTL = 0x1 IP_DF = 0x4000 + IP_DIVERTFL = 0x1022 IP_DROP_MEMBERSHIP = 0xd IP_ESP_NETWORK_LEVEL = 0x16 IP_ESP_TRANS_LEVEL = 0x15 @@ -863,6 +861,32 @@ const ( LOCK_NB = 0x4 LOCK_SH = 0x1 LOCK_UN = 0x8 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x6 + MADV_NORMAL = 0x0 + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_SPACEAVAIL = 0x5 + MADV_WILLNEED = 0x3 + MAP_ANON = 0x1000 + MAP_COPY = 0x4 + MAP_FILE = 0x0 + MAP_FIXED = 0x10 + MAP_FLAGMASK = 0x1ff7 + MAP_HASSEMAPHORE = 0x200 + MAP_INHERIT = 0x80 + MAP_INHERIT_COPY = 0x1 + MAP_INHERIT_DONATE_COPY = 0x3 + MAP_INHERIT_NONE = 0x2 + MAP_INHERIT_SHARE = 0x0 + MAP_NOEXTEND = 0x100 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_SHARED = 0x1 + MAP_TRYFIXED = 0x400 + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 MSG_BCAST = 0x100 MSG_CTRUNC = 0x20 MSG_DONTROUTE = 0x4 @@ -874,6 +898,9 @@ const ( MSG_PEEK = 0x2 MSG_TRUNC = 0x10 MSG_WAITALL = 0x40 + MS_ASYNC = 0x1 + MS_INVALIDATE = 0x4 + MS_SYNC = 0x2 NAME_MAX = 0xff NET_RT_DUMP = 0x1 NET_RT_FLAGS = 0x2 @@ -932,10 +959,13 @@ const ( PARODD = 0x2000 PENDIN = 0x20000000 PF_FLUSH = 0x1 - PMC5_PIPELINE_FLUSH = 0x15 PRIO_PGRP = 0x1 PRIO_PROCESS = 0x0 PRIO_USER = 0x2 + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 RLIMIT_CORE = 0x4 RLIMIT_CPU = 0x0 RLIMIT_DATA = 0x2 @@ -972,7 +1002,7 @@ const ( RTF_CLONING = 0x100 RTF_DONE = 0x40 RTF_DYNAMIC = 0x10 - RTF_FMASK = 0xf808 + RTF_FMASK = 0x10f808 RTF_GATEWAY = 0x2 RTF_HOST = 0x4 RTF_LLINFO = 0x400 @@ -1007,7 +1037,7 @@ const ( RTM_REDIRECT = 0x6 RTM_RESOLVE = 0xb RTM_RTTUNIT = 0xf4240 - RTM_VERSION = 0x4 + RTM_VERSION = 0x5 RTV_EXPIRE = 0x4 RTV_HOPCOUNT = 0x2 RTV_MTU = 0x1 @@ -1033,7 +1063,7 @@ const ( SIOCBRDGADD = 0x8058693c SIOCBRDGADDS = 0x80586941 SIOCBRDGARL = 0x806e694d - SIOCBRDGDADDR = 0x80286947 + SIOCBRDGDADDR = 0x81286947 SIOCBRDGDEL = 0x8058693d SIOCBRDGDELS = 0x80586942 SIOCBRDGFLUSH = 0x80586948 @@ -1050,7 +1080,7 @@ const ( SIOCBRDGGTO = 0xc0146946 SIOCBRDGIFS = 0xc0586942 SIOCBRDGRTS = 0xc0206943 - SIOCBRDGSADDR = 0xc0286944 + SIOCBRDGSADDR = 0xc1286944 SIOCBRDGSCACHE = 0x80146940 SIOCBRDGSFD = 0x80146952 SIOCBRDGSHT = 0x80146951 @@ -1073,6 +1103,7 @@ const ( SIOCGETPFSYNC = 0xc02069f8 SIOCGETSGCNT = 0xc0207534 SIOCGETVIFCNT = 0xc0287533 + SIOCGETVLAN = 0xc0206990 SIOCGHIWAT = 0x40047301 SIOCGIFADDR = 0xc0206921 SIOCGIFASYNCMAP = 0xc020697c @@ -1086,6 +1117,7 @@ const ( SIOCGIFGENERIC = 0xc020693a SIOCGIFGMEMB = 0xc028698a SIOCGIFGROUP = 0xc0286988 + SIOCGIFHARDMTU = 0xc02069a5 SIOCGIFMEDIA = 0xc0306936 SIOCGIFMETRIC = 0xc0206917 SIOCGIFMTU = 0xc020697e @@ -1100,9 +1132,12 @@ const ( SIOCGLIFADDR = 0xc218691d SIOCGLIFPHYADDR = 0xc218694b SIOCGLIFPHYRTABLE = 0xc02069a2 + SIOCGLIFPHYTTL = 0xc02069a9 SIOCGLOWAT = 0x40047303 SIOCGPGRP = 0x40047309 + SIOCGSPPPPARAMS = 0xc0206994 SIOCGVH = 0xc02069f6 + SIOCGVNETID = 0xc02069a7 SIOCIFCREATE = 0x8020697a SIOCIFDESTROY = 0x80206979 SIOCIFGCLONERS = 0xc0106978 @@ -1110,6 +1145,7 @@ const ( SIOCSETLABEL = 0x80206999 SIOCSETPFLOW = 0x802069fd SIOCSETPFSYNC = 0x802069f7 + SIOCSETVLAN = 0x8020698f SIOCSHIWAT = 0x80047300 SIOCSIFADDR = 0x8020690c SIOCSIFASYNCMAP = 0x8020697d @@ -1132,9 +1168,12 @@ const ( SIOCSIFXFLAGS = 0x8020699d SIOCSLIFPHYADDR = 0x8218694a SIOCSLIFPHYRTABLE = 0x802069a1 + SIOCSLIFPHYTTL = 0x802069a8 SIOCSLOWAT = 0x80047302 SIOCSPGRP = 0x80047308 + SIOCSSPPPPARAMS = 0x80206993 SIOCSVH = 0xc02069f5 + SIOCSVNETID = 0x802069a6 SOCK_DGRAM = 0x2 SOCK_RAW = 0x3 SOCK_RDM = 0x4 @@ -1177,6 +1216,7 @@ const ( TCP_MD5SIG = 0x4 TCP_MSS = 0x200 TCP_NODELAY = 0x1 + TCP_NOPUSH = 0x10 TCP_NSTATES = 0xb TCP_SACK_ENABLE = 0x8 TCSAFLUSH = 0x2 @@ -1196,6 +1236,7 @@ const ( TIOCGETD = 0x4004741a TIOCGFLAGS = 0x4004745d TIOCGPGRP = 0x40047477 + TIOCGSID = 0x40047463 TIOCGTSTAMP = 0x4010745b TIOCGWINSZ = 0x40087468 TIOCMBIC = 0x8004746b diff --git a/src/pkg/syscall/zerrors_solaris_amd64.go b/src/pkg/syscall/zerrors_solaris_amd64.go new file mode 100644 index 000000000..3f4cbfd98 --- /dev/null +++ b/src/pkg/syscall/zerrors_solaris_amd64.go @@ -0,0 +1,1414 @@ +// mkerrors.sh -m64 +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs -- -m64 _const.go + +package syscall + +const ( + AF_802 = 0x12 + AF_APPLETALK = 0x10 + AF_CCITT = 0xa + AF_CHAOS = 0x5 + AF_DATAKIT = 0x9 + AF_DECnet = 0xc + AF_DLI = 0xd + AF_ECMA = 0x8 + AF_FILE = 0x1 + AF_GOSIP = 0x16 + AF_HYLINK = 0xf + AF_IMPLINK = 0x3 + AF_INET = 0x2 + AF_INET6 = 0x1a + AF_INET_OFFLOAD = 0x1e + AF_IPX = 0x17 + AF_KEY = 0x1b + AF_LAT = 0xe + AF_LINK = 0x19 + AF_LOCAL = 0x1 + AF_MAX = 0x20 + AF_NBS = 0x7 + AF_NCA = 0x1c + AF_NIT = 0x11 + AF_NS = 0x6 + AF_OSI = 0x13 + AF_OSINET = 0x15 + AF_PACKET = 0x20 + AF_POLICY = 0x1d + AF_PUP = 0x4 + AF_ROUTE = 0x18 + AF_SNA = 0xb + AF_TRILL = 0x1f + AF_UNIX = 0x1 + AF_UNSPEC = 0x0 + AF_X25 = 0x14 + ARPHRD_ARCNET = 0x7 + ARPHRD_ATM = 0x10 + ARPHRD_AX25 = 0x3 + ARPHRD_CHAOS = 0x5 + ARPHRD_EETHER = 0x2 + ARPHRD_ETHER = 0x1 + ARPHRD_FC = 0x12 + ARPHRD_FRAME = 0xf + ARPHRD_HDLC = 0x11 + ARPHRD_IB = 0x20 + ARPHRD_IEEE802 = 0x6 + ARPHRD_IPATM = 0x13 + ARPHRD_METRICOM = 0x17 + ARPHRD_TUNNEL = 0x1f + B0 = 0x0 + B110 = 0x3 + B115200 = 0x12 + B1200 = 0x9 + B134 = 0x4 + B150 = 0x5 + B153600 = 0x13 + B1800 = 0xa + B19200 = 0xe + B200 = 0x6 + B230400 = 0x14 + B2400 = 0xb + B300 = 0x7 + B307200 = 0x15 + B38400 = 0xf + B460800 = 0x16 + B4800 = 0xc + B50 = 0x1 + B57600 = 0x10 + B600 = 0x8 + B75 = 0x2 + B76800 = 0x11 + B921600 = 0x17 + B9600 = 0xd + BIOCFLUSH = 0x20004268 + BIOCGBLEN = 0x40044266 + BIOCGDLT = 0x4004426a + BIOCGDLTLIST = -0x3fefbd89 + BIOCGDLTLIST32 = -0x3ff7bd89 + BIOCGETIF = 0x4020426b + BIOCGETLIF = 0x4078426b + BIOCGHDRCMPLT = 0x40044274 + BIOCGRTIMEOUT = 0x4010427b + BIOCGRTIMEOUT32 = 0x4008427b + BIOCGSEESENT = 0x40044278 + BIOCGSTATS = 0x4080426f + BIOCGSTATSOLD = 0x4008426f + BIOCIMMEDIATE = -0x7ffbbd90 + BIOCPROMISC = 0x20004269 + BIOCSBLEN = -0x3ffbbd9a + BIOCSDLT = -0x7ffbbd8a + BIOCSETF = -0x7fefbd99 + BIOCSETF32 = -0x7ff7bd99 + BIOCSETIF = -0x7fdfbd94 + BIOCSETLIF = -0x7f87bd94 + BIOCSHDRCMPLT = -0x7ffbbd8b + BIOCSRTIMEOUT = -0x7fefbd86 + BIOCSRTIMEOUT32 = -0x7ff7bd86 + BIOCSSEESENT = -0x7ffbbd87 + BIOCSTCPF = -0x7fefbd8e + BIOCSUDPF = -0x7fefbd8d + BIOCVERSION = 0x40044271 + BPF_A = 0x10 + BPF_ABS = 0x20 + BPF_ADD = 0x0 + BPF_ALIGNMENT = 0x4 + BPF_ALU = 0x4 + BPF_AND = 0x50 + BPF_B = 0x10 + BPF_DFLTBUFSIZE = 0x100000 + BPF_DIV = 0x30 + BPF_H = 0x8 + BPF_IMM = 0x0 + BPF_IND = 0x40 + BPF_JA = 0x0 + BPF_JEQ = 0x10 + BPF_JGE = 0x30 + BPF_JGT = 0x20 + BPF_JMP = 0x5 + BPF_JSET = 0x40 + BPF_K = 0x0 + BPF_LD = 0x0 + BPF_LDX = 0x1 + BPF_LEN = 0x80 + BPF_LSH = 0x60 + BPF_MAJOR_VERSION = 0x1 + BPF_MAXBUFSIZE = 0x1000000 + BPF_MAXINSNS = 0x200 + BPF_MEM = 0x60 + BPF_MEMWORDS = 0x10 + BPF_MINBUFSIZE = 0x20 + BPF_MINOR_VERSION = 0x1 + BPF_MISC = 0x7 + BPF_MSH = 0xa0 + BPF_MUL = 0x20 + BPF_NEG = 0x80 + BPF_OR = 0x40 + BPF_RELEASE = 0x30bb6 + BPF_RET = 0x6 + BPF_RSH = 0x70 + BPF_ST = 0x2 + BPF_STX = 0x3 + BPF_SUB = 0x10 + BPF_TAX = 0x0 + BPF_TXA = 0x80 + BPF_W = 0x0 + BPF_X = 0x8 + BRKINT = 0x2 + CFLUSH = 0xf + CLOCAL = 0x800 + CREAD = 0x80 + CS5 = 0x0 + CS6 = 0x10 + CS7 = 0x20 + CS8 = 0x30 + CSIZE = 0x30 + CSTART = 0x11 + CSTOP = 0x13 + CSTOPB = 0x40 + CSUSP = 0x1a + CSWTCH = 0x1a + DLT_AIRONET_HEADER = 0x78 + DLT_APPLE_IP_OVER_IEEE1394 = 0x8a + DLT_ARCNET = 0x7 + DLT_ARCNET_LINUX = 0x81 + DLT_ATM_CLIP = 0x13 + DLT_ATM_RFC1483 = 0xb + DLT_AURORA = 0x7e + DLT_AX25 = 0x3 + DLT_BACNET_MS_TP = 0xa5 + DLT_CHAOS = 0x5 + DLT_CISCO_IOS = 0x76 + DLT_C_HDLC = 0x68 + DLT_DOCSIS = 0x8f + DLT_ECONET = 0x73 + DLT_EN10MB = 0x1 + DLT_EN3MB = 0x2 + DLT_ENC = 0x6d + DLT_ERF_ETH = 0xaf + DLT_ERF_POS = 0xb0 + DLT_FDDI = 0xa + DLT_FRELAY = 0x6b + DLT_GCOM_SERIAL = 0xad + DLT_GCOM_T1E1 = 0xac + DLT_GPF_F = 0xab + DLT_GPF_T = 0xaa + DLT_GPRS_LLC = 0xa9 + DLT_HDLC = 0x10 + DLT_HHDLC = 0x79 + DLT_HIPPI = 0xf + DLT_IBM_SN = 0x92 + DLT_IBM_SP = 0x91 + DLT_IEEE802 = 0x6 + DLT_IEEE802_11 = 0x69 + DLT_IEEE802_11_RADIO = 0x7f + DLT_IEEE802_11_RADIO_AVS = 0xa3 + DLT_IPNET = 0xe2 + DLT_IPOIB = 0xa2 + DLT_IP_OVER_FC = 0x7a + DLT_JUNIPER_ATM1 = 0x89 + DLT_JUNIPER_ATM2 = 0x87 + DLT_JUNIPER_CHDLC = 0xb5 + DLT_JUNIPER_ES = 0x84 + DLT_JUNIPER_ETHER = 0xb2 + DLT_JUNIPER_FRELAY = 0xb4 + DLT_JUNIPER_GGSN = 0x85 + DLT_JUNIPER_MFR = 0x86 + DLT_JUNIPER_MLFR = 0x83 + DLT_JUNIPER_MLPPP = 0x82 + DLT_JUNIPER_MONITOR = 0xa4 + DLT_JUNIPER_PIC_PEER = 0xae + DLT_JUNIPER_PPP = 0xb3 + DLT_JUNIPER_PPPOE = 0xa7 + DLT_JUNIPER_PPPOE_ATM = 0xa8 + DLT_JUNIPER_SERVICES = 0x88 + DLT_LINUX_IRDA = 0x90 + DLT_LINUX_LAPD = 0xb1 + DLT_LINUX_SLL = 0x71 + DLT_LOOP = 0x6c + DLT_LTALK = 0x72 + DLT_MTP2 = 0x8c + DLT_MTP2_WITH_PHDR = 0x8b + DLT_MTP3 = 0x8d + DLT_NULL = 0x0 + DLT_PCI_EXP = 0x7d + DLT_PFLOG = 0x75 + DLT_PFSYNC = 0x12 + DLT_PPP = 0x9 + DLT_PPP_BSDOS = 0xe + DLT_PPP_PPPD = 0xa6 + DLT_PRISM_HEADER = 0x77 + DLT_PRONET = 0x4 + DLT_RAW = 0xc + DLT_RAWAF_MASK = 0x2240000 + DLT_RIO = 0x7c + DLT_SCCP = 0x8e + DLT_SLIP = 0x8 + DLT_SLIP_BSDOS = 0xd + DLT_SUNATM = 0x7b + DLT_SYMANTEC_FIREWALL = 0x63 + DLT_TZSP = 0x80 + ECHO = 0x8 + ECHOCTL = 0x200 + ECHOE = 0x10 + ECHOK = 0x20 + ECHOKE = 0x800 + ECHONL = 0x40 + ECHOPRT = 0x400 + EMPTY_SET = 0x0 + EMT_CPCOVF = 0x1 + EQUALITY_CHECK = 0x0 + EXTA = 0xe + EXTB = 0xf + FD_CLOEXEC = 0x1 + FD_NFDBITS = 0x40 + FD_SETSIZE = 0x10000 + FLUSHALL = 0x1 + FLUSHDATA = 0x0 + FLUSHO = 0x2000 + F_ALLOCSP = 0xa + F_ALLOCSP64 = 0xa + F_BADFD = 0x2e + F_BLKSIZE = 0x13 + F_BLOCKS = 0x12 + F_CHKFL = 0x8 + F_COMPAT = 0x8 + F_DUP2FD = 0x9 + F_DUP2FD_CLOEXEC = 0x24 + F_DUPFD = 0x0 + F_DUPFD_CLOEXEC = 0x25 + F_FREESP = 0xb + F_FREESP64 = 0xb + F_GETFD = 0x1 + F_GETFL = 0x3 + F_GETLK = 0xe + F_GETLK64 = 0xe + F_GETOWN = 0x17 + F_GETXFL = 0x2d + F_HASREMOTELOCKS = 0x1a + F_ISSTREAM = 0xd + F_MANDDNY = 0x10 + F_MDACC = 0x20 + F_NODNY = 0x0 + F_NPRIV = 0x10 + F_PRIV = 0xf + F_QUOTACTL = 0x11 + F_RDACC = 0x1 + F_RDDNY = 0x1 + F_RDLCK = 0x1 + F_REVOKE = 0x19 + F_RMACC = 0x4 + F_RMDNY = 0x4 + F_RWACC = 0x3 + F_RWDNY = 0x3 + F_SETFD = 0x2 + F_SETFL = 0x4 + F_SETLK = 0x6 + F_SETLK64 = 0x6 + F_SETLK64_NBMAND = 0x2a + F_SETLKW = 0x7 + F_SETLKW64 = 0x7 + F_SETLK_NBMAND = 0x2a + F_SETOWN = 0x18 + F_SHARE = 0x28 + F_SHARE_NBMAND = 0x2b + F_UNLCK = 0x3 + F_UNLKSYS = 0x4 + F_UNSHARE = 0x29 + F_WRACC = 0x2 + F_WRDNY = 0x2 + F_WRLCK = 0x2 + HUPCL = 0x400 + ICANON = 0x2 + ICRNL = 0x100 + IEXTEN = 0x8000 + IFF_ADDRCONF = 0x80000 + IFF_ALLMULTI = 0x200 + IFF_ANYCAST = 0x400000 + IFF_BROADCAST = 0x2 + IFF_CANTCHANGE = 0x7f203003b5a + IFF_COS_ENABLED = 0x200000000 + IFF_DEBUG = 0x4 + IFF_DEPRECATED = 0x40000 + IFF_DHCPRUNNING = 0x4000 + IFF_DUPLICATE = 0x4000000000 + IFF_FAILED = 0x10000000 + IFF_FIXEDMTU = 0x1000000000 + IFF_INACTIVE = 0x40000000 + IFF_INTELLIGENT = 0x400 + IFF_IPMP = 0x8000000000 + IFF_IPMP_CANTCHANGE = 0x10000000 + IFF_IPMP_INVALID = 0x1ec200080 + IFF_IPV4 = 0x1000000 + IFF_IPV6 = 0x2000000 + IFF_L3PROTECT = 0x40000000000 + IFF_LOOPBACK = 0x8 + IFF_MULTICAST = 0x800 + IFF_MULTI_BCAST = 0x1000 + IFF_NOACCEPT = 0x4000000 + IFF_NOARP = 0x80 + IFF_NOFAILOVER = 0x8000000 + IFF_NOLINKLOCAL = 0x20000000000 + IFF_NOLOCAL = 0x20000 + IFF_NONUD = 0x200000 + IFF_NORTEXCH = 0x800000 + IFF_NOTRAILERS = 0x20 + IFF_NOXMIT = 0x10000 + IFF_OFFLINE = 0x80000000 + IFF_POINTOPOINT = 0x10 + IFF_PREFERRED = 0x400000000 + IFF_PRIVATE = 0x8000 + IFF_PROMISC = 0x100 + IFF_ROUTER = 0x100000 + IFF_RUNNING = 0x40 + IFF_STANDBY = 0x20000000 + IFF_TEMPORARY = 0x800000000 + IFF_UNNUMBERED = 0x2000 + IFF_UP = 0x1 + IFF_VIRTUAL = 0x2000000000 + IFF_VRRP = 0x10000000000 + IFF_XRESOLV = 0x100000000 + IFNAMSIZ = 0x10 + IFT_1822 = 0x2 + IFT_6TO4 = 0xca + IFT_AAL5 = 0x31 + IFT_ARCNET = 0x23 + IFT_ARCNETPLUS = 0x24 + IFT_ATM = 0x25 + IFT_CEPT = 0x13 + IFT_DS3 = 0x1e + IFT_EON = 0x19 + IFT_ETHER = 0x6 + IFT_FDDI = 0xf + IFT_FRELAY = 0x20 + IFT_FRELAYDCE = 0x2c + IFT_HDH1822 = 0x3 + IFT_HIPPI = 0x2f + IFT_HSSI = 0x2e + IFT_HY = 0xe + IFT_IB = 0xc7 + IFT_IPV4 = 0xc8 + IFT_IPV6 = 0xc9 + IFT_ISDNBASIC = 0x14 + IFT_ISDNPRIMARY = 0x15 + IFT_ISO88022LLC = 0x29 + IFT_ISO88023 = 0x7 + IFT_ISO88024 = 0x8 + IFT_ISO88025 = 0x9 + IFT_ISO88026 = 0xa + IFT_LAPB = 0x10 + IFT_LOCALTALK = 0x2a + IFT_LOOP = 0x18 + IFT_MIOX25 = 0x26 + IFT_MODEM = 0x30 + IFT_NSIP = 0x1b + IFT_OTHER = 0x1 + IFT_P10 = 0xc + IFT_P80 = 0xd + IFT_PARA = 0x22 + IFT_PPP = 0x17 + IFT_PROPMUX = 0x36 + IFT_PROPVIRTUAL = 0x35 + IFT_PTPSERIAL = 0x16 + IFT_RS232 = 0x21 + IFT_SDLC = 0x11 + IFT_SIP = 0x1f + IFT_SLIP = 0x1c + IFT_SMDSDXI = 0x2b + IFT_SMDSICIP = 0x34 + IFT_SONET = 0x27 + IFT_SONETPATH = 0x32 + IFT_SONETVT = 0x33 + IFT_STARLAN = 0xb + IFT_T1 = 0x12 + IFT_ULTRA = 0x1d + IFT_V35 = 0x2d + IFT_X25 = 0x5 + IFT_X25DDN = 0x4 + IFT_X25PLE = 0x28 + IFT_XETHER = 0x1a + IGNBRK = 0x1 + IGNCR = 0x80 + IGNPAR = 0x4 + IMAXBEL = 0x2000 + INLCR = 0x40 + INPCK = 0x10 + IN_AUTOCONF_MASK = 0xffff0000 + IN_AUTOCONF_NET = 0xa9fe0000 + IN_CLASSA_HOST = 0xffffff + IN_CLASSA_MAX = 0x80 + IN_CLASSA_NET = 0xff000000 + IN_CLASSA_NSHIFT = 0x18 + IN_CLASSB_HOST = 0xffff + IN_CLASSB_MAX = 0x10000 + IN_CLASSB_NET = 0xffff0000 + IN_CLASSB_NSHIFT = 0x10 + IN_CLASSC_HOST = 0xff + IN_CLASSC_NET = 0xffffff00 + IN_CLASSC_NSHIFT = 0x8 + IN_CLASSD_HOST = 0xfffffff + IN_CLASSD_NET = 0xf0000000 + IN_CLASSD_NSHIFT = 0x1c + IN_CLASSE_NET = 0xffffffff + IN_LOOPBACKNET = 0x7f + IN_PRIVATE12_MASK = 0xfff00000 + IN_PRIVATE12_NET = 0xac100000 + IN_PRIVATE16_MASK = 0xffff0000 + IN_PRIVATE16_NET = 0xc0a80000 + IN_PRIVATE8_MASK = 0xff000000 + IN_PRIVATE8_NET = 0xa000000 + IPPROTO_AH = 0x33 + IPPROTO_DSTOPTS = 0x3c + IPPROTO_EGP = 0x8 + IPPROTO_ENCAP = 0x4 + IPPROTO_EON = 0x50 + IPPROTO_ESP = 0x32 + IPPROTO_FRAGMENT = 0x2c + IPPROTO_GGP = 0x3 + IPPROTO_HELLO = 0x3f + IPPROTO_HOPOPTS = 0x0 + IPPROTO_ICMP = 0x1 + IPPROTO_ICMPV6 = 0x3a + IPPROTO_IDP = 0x16 + IPPROTO_IGMP = 0x2 + IPPROTO_IP = 0x0 + IPPROTO_IPV6 = 0x29 + IPPROTO_MAX = 0x100 + IPPROTO_ND = 0x4d + IPPROTO_NONE = 0x3b + IPPROTO_OSPF = 0x59 + IPPROTO_PIM = 0x67 + IPPROTO_PUP = 0xc + IPPROTO_RAW = 0xff + IPPROTO_ROUTING = 0x2b + IPPROTO_RSVP = 0x2e + IPPROTO_SCTP = 0x84 + IPPROTO_TCP = 0x6 + IPPROTO_UDP = 0x11 + IPV6_ADD_MEMBERSHIP = 0x9 + IPV6_BOUND_IF = 0x41 + IPV6_CHECKSUM = 0x18 + IPV6_DONTFRAG = 0x21 + IPV6_DROP_MEMBERSHIP = 0xa + IPV6_DSTOPTS = 0xf + IPV6_FLOWINFO_FLOWLABEL = 0xffff0f00 + IPV6_FLOWINFO_TCLASS = 0xf00f + IPV6_HOPLIMIT = 0xc + IPV6_HOPOPTS = 0xe + IPV6_JOIN_GROUP = 0x9 + IPV6_LEAVE_GROUP = 0xa + IPV6_MULTICAST_HOPS = 0x7 + IPV6_MULTICAST_IF = 0x6 + IPV6_MULTICAST_LOOP = 0x8 + IPV6_NEXTHOP = 0xd + IPV6_PAD1_OPT = 0x0 + IPV6_PATHMTU = 0x25 + IPV6_PKTINFO = 0xb + IPV6_PREFER_SRC_CGA = 0x20 + IPV6_PREFER_SRC_CGADEFAULT = 0x10 + IPV6_PREFER_SRC_CGAMASK = 0x30 + IPV6_PREFER_SRC_COA = 0x2 + IPV6_PREFER_SRC_DEFAULT = 0x15 + IPV6_PREFER_SRC_HOME = 0x1 + IPV6_PREFER_SRC_MASK = 0x3f + IPV6_PREFER_SRC_MIPDEFAULT = 0x1 + IPV6_PREFER_SRC_MIPMASK = 0x3 + IPV6_PREFER_SRC_NONCGA = 0x10 + IPV6_PREFER_SRC_PUBLIC = 0x4 + IPV6_PREFER_SRC_TMP = 0x8 + IPV6_PREFER_SRC_TMPDEFAULT = 0x4 + IPV6_PREFER_SRC_TMPMASK = 0xc + IPV6_RECVDSTOPTS = 0x28 + IPV6_RECVHOPLIMIT = 0x13 + IPV6_RECVHOPOPTS = 0x14 + IPV6_RECVPATHMTU = 0x24 + IPV6_RECVPKTINFO = 0x12 + IPV6_RECVRTHDR = 0x16 + IPV6_RECVRTHDRDSTOPTS = 0x17 + IPV6_RECVTCLASS = 0x19 + IPV6_RTHDR = 0x10 + IPV6_RTHDRDSTOPTS = 0x11 + IPV6_RTHDR_TYPE_0 = 0x0 + IPV6_SEC_OPT = 0x22 + IPV6_SRC_PREFERENCES = 0x23 + IPV6_TCLASS = 0x26 + IPV6_UNICAST_HOPS = 0x5 + IPV6_UNSPEC_SRC = 0x42 + IPV6_USE_MIN_MTU = 0x20 + IPV6_V6ONLY = 0x27 + IP_ADD_MEMBERSHIP = 0x13 + IP_ADD_SOURCE_MEMBERSHIP = 0x17 + IP_BLOCK_SOURCE = 0x15 + IP_BOUND_IF = 0x41 + IP_BROADCAST = 0x106 + IP_BROADCAST_TTL = 0x43 + IP_DEFAULT_MULTICAST_LOOP = 0x1 + IP_DEFAULT_MULTICAST_TTL = 0x1 + IP_DF = 0x4000 + IP_DHCPINIT_IF = 0x45 + IP_DONTFRAG = 0x1b + IP_DONTROUTE = 0x105 + IP_DROP_MEMBERSHIP = 0x14 + IP_DROP_SOURCE_MEMBERSHIP = 0x18 + IP_HDRINCL = 0x2 + IP_MAXPACKET = 0xffff + IP_MF = 0x2000 + IP_MSS = 0x240 + IP_MULTICAST_IF = 0x10 + IP_MULTICAST_LOOP = 0x12 + IP_MULTICAST_TTL = 0x11 + IP_NEXTHOP = 0x19 + IP_OPTIONS = 0x1 + IP_PKTINFO = 0x1a + IP_RECVDSTADDR = 0x7 + IP_RECVIF = 0x9 + IP_RECVOPTS = 0x5 + IP_RECVPKTINFO = 0x1a + IP_RECVRETOPTS = 0x6 + IP_RECVSLLA = 0xa + IP_RECVTTL = 0xb + IP_RETOPTS = 0x8 + IP_REUSEADDR = 0x104 + IP_SEC_OPT = 0x22 + IP_TOS = 0x3 + IP_TTL = 0x4 + IP_UNBLOCK_SOURCE = 0x16 + IP_UNSPEC_SRC = 0x42 + ISIG = 0x1 + ISTRIP = 0x20 + IXANY = 0x800 + IXOFF = 0x1000 + IXON = 0x400 + MADV_ACCESS_DEFAULT = 0x6 + MADV_ACCESS_LWP = 0x7 + MADV_ACCESS_MANY = 0x8 + MADV_DONTNEED = 0x4 + MADV_FREE = 0x5 + MADV_NORMAL = 0x0 + MADV_RANDOM = 0x1 + MADV_SEQUENTIAL = 0x2 + MADV_WILLNEED = 0x3 + MAP_32BIT = 0x80 + MAP_ALIGN = 0x200 + MAP_ANON = 0x100 + MAP_ANONYMOUS = 0x100 + MAP_FIXED = 0x10 + MAP_INITDATA = 0x800 + MAP_NORESERVE = 0x40 + MAP_PRIVATE = 0x2 + MAP_RENAME = 0x20 + MAP_SHARED = 0x1 + MAP_TEXT = 0x400 + MAP_TYPE = 0xf + MCL_CURRENT = 0x1 + MCL_FUTURE = 0x2 + MSG_CTRUNC = 0x10 + MSG_DONTROUTE = 0x4 + MSG_DONTWAIT = 0x80 + MSG_DUPCTRL = 0x800 + MSG_EOR = 0x8 + MSG_MAXIOVLEN = 0x10 + MSG_NOTIFICATION = 0x100 + MSG_OOB = 0x1 + MSG_PEEK = 0x2 + MSG_TRUNC = 0x20 + MSG_WAITALL = 0x40 + MSG_XPG4_2 = 0x8000 + MS_ASYNC = 0x1 + MS_INVALIDATE = 0x2 + MS_OLDSYNC = 0x0 + MS_SYNC = 0x4 + M_FLUSH = 0x86 + NOFLSH = 0x80 + OCRNL = 0x8 + OFDEL = 0x80 + OFILL = 0x40 + ONLCR = 0x4 + ONLRET = 0x20 + ONOCR = 0x10 + OPENFAIL = -0x1 + OPOST = 0x1 + O_ACCMODE = 0x600003 + O_APPEND = 0x8 + O_CLOEXEC = 0x800000 + O_CREAT = 0x100 + O_DSYNC = 0x40 + O_EXCL = 0x400 + O_EXEC = 0x400000 + O_LARGEFILE = 0x2000 + O_NDELAY = 0x4 + O_NOCTTY = 0x800 + O_NOFOLLOW = 0x20000 + O_NOLINKS = 0x40000 + O_NONBLOCK = 0x80 + O_RDONLY = 0x0 + O_RDWR = 0x2 + O_RSYNC = 0x8000 + O_SEARCH = 0x200000 + O_SIOCGIFCONF = -0x3ff796ec + O_SIOCGLIFCONF = -0x3fef9688 + O_SYNC = 0x10 + O_TRUNC = 0x200 + O_WRONLY = 0x1 + O_XATTR = 0x4000 + PARENB = 0x100 + PAREXT = 0x100000 + PARMRK = 0x8 + PARODD = 0x200 + PENDIN = 0x4000 + PRIO_PGRP = 0x1 + PRIO_PROCESS = 0x0 + PRIO_USER = 0x2 + PROT_EXEC = 0x4 + PROT_NONE = 0x0 + PROT_READ = 0x1 + PROT_WRITE = 0x2 + RLIMIT_AS = 0x6 + RLIMIT_CORE = 0x4 + RLIMIT_CPU = 0x0 + RLIMIT_DATA = 0x2 + RLIMIT_FSIZE = 0x1 + RLIMIT_NOFILE = 0x5 + RLIMIT_STACK = 0x3 + RLIM_INFINITY = -0x3 + RTAX_AUTHOR = 0x6 + RTAX_BRD = 0x7 + RTAX_DST = 0x0 + RTAX_GATEWAY = 0x1 + RTAX_GENMASK = 0x3 + RTAX_IFA = 0x5 + RTAX_IFP = 0x4 + RTAX_MAX = 0x9 + RTAX_NETMASK = 0x2 + RTAX_SRC = 0x8 + RTA_AUTHOR = 0x40 + RTA_BRD = 0x80 + RTA_DST = 0x1 + RTA_GATEWAY = 0x2 + RTA_GENMASK = 0x8 + RTA_IFA = 0x20 + RTA_IFP = 0x10 + RTA_NETMASK = 0x4 + RTA_NUMBITS = 0x9 + RTA_SRC = 0x100 + RTF_BLACKHOLE = 0x1000 + RTF_CLONING = 0x100 + RTF_DONE = 0x40 + RTF_DYNAMIC = 0x10 + RTF_GATEWAY = 0x2 + RTF_HOST = 0x4 + RTF_INDIRECT = 0x40000 + RTF_KERNEL = 0x80000 + RTF_LLINFO = 0x400 + RTF_MASK = 0x80 + RTF_MODIFIED = 0x20 + RTF_MULTIRT = 0x10000 + RTF_PRIVATE = 0x2000 + RTF_PROTO1 = 0x8000 + RTF_PROTO2 = 0x4000 + RTF_REJECT = 0x8 + RTF_SETSRC = 0x20000 + RTF_STATIC = 0x800 + RTF_UP = 0x1 + RTF_XRESOLVE = 0x200 + RTF_ZONE = 0x100000 + RTM_ADD = 0x1 + RTM_CHANGE = 0x3 + RTM_CHGADDR = 0xf + RTM_DELADDR = 0xd + RTM_DELETE = 0x2 + RTM_FREEADDR = 0x10 + RTM_GET = 0x4 + RTM_IFINFO = 0xe + RTM_LOCK = 0x8 + RTM_LOSING = 0x5 + RTM_MISS = 0x7 + RTM_NEWADDR = 0xc + RTM_OLDADD = 0x9 + RTM_OLDDEL = 0xa + RTM_REDIRECT = 0x6 + RTM_RESOLVE = 0xb + RTM_VERSION = 0x3 + RTV_EXPIRE = 0x4 + RTV_HOPCOUNT = 0x2 + RTV_MTU = 0x1 + RTV_RPIPE = 0x8 + RTV_RTT = 0x40 + RTV_RTTVAR = 0x80 + RTV_SPIPE = 0x10 + RTV_SSTHRESH = 0x20 + RT_AWARE = 0x1 + RUSAGE_CHILDREN = -0x1 + RUSAGE_SELF = 0x0 + SCM_RIGHTS = 0x1010 + SCM_TIMESTAMP = 0x1013 + SCM_UCRED = 0x1012 + SHUT_RD = 0x0 + SHUT_RDWR = 0x2 + SHUT_WR = 0x1 + SIG2STR_MAX = 0x20 + SIOCADDMULTI = -0x7fdf96cf + SIOCADDRT = -0x7fcf8df6 + SIOCATMARK = 0x40047307 + SIOCDARP = -0x7fdb96e0 + SIOCDELMULTI = -0x7fdf96ce + SIOCDELRT = -0x7fcf8df5 + SIOCDIPSECONFIG = -0x7ffb9669 + SIOCDXARP = -0x7fff9658 + SIOCFIPSECONFIG = -0x7ffb966b + SIOCGARP = -0x3fdb96e1 + SIOCGDSTINFO = -0x3fff965c + SIOCGENADDR = -0x3fdf96ab + SIOCGENPSTATS = -0x3fdf96c7 + SIOCGETLSGCNT = -0x3fef8deb + SIOCGETNAME = 0x40107334 + SIOCGETPEER = 0x40107335 + SIOCGETPROP = -0x3fff8f44 + SIOCGETSGCNT = -0x3feb8deb + SIOCGETSYNC = -0x3fdf96d3 + SIOCGETVIFCNT = -0x3feb8dec + SIOCGHIWAT = 0x40047301 + SIOCGIFADDR = -0x3fdf96f3 + SIOCGIFBRDADDR = -0x3fdf96e9 + SIOCGIFCONF = -0x3ff796a4 + SIOCGIFDSTADDR = -0x3fdf96f1 + SIOCGIFFLAGS = -0x3fdf96ef + SIOCGIFHWADDR = -0x3fdf9647 + SIOCGIFINDEX = -0x3fdf96a6 + SIOCGIFMEM = -0x3fdf96ed + SIOCGIFMETRIC = -0x3fdf96e5 + SIOCGIFMTU = -0x3fdf96ea + SIOCGIFMUXID = -0x3fdf96a8 + SIOCGIFNETMASK = -0x3fdf96e7 + SIOCGIFNUM = 0x40046957 + SIOCGIP6ADDRPOLICY = -0x3fff965e + SIOCGIPMSFILTER = -0x3ffb964c + SIOCGLIFADDR = -0x3f87968f + SIOCGLIFBINDING = -0x3f879666 + SIOCGLIFBRDADDR = -0x3f879685 + SIOCGLIFCONF = -0x3fef965b + SIOCGLIFDADSTATE = -0x3f879642 + SIOCGLIFDSTADDR = -0x3f87968d + SIOCGLIFFLAGS = -0x3f87968b + SIOCGLIFGROUPINFO = -0x3f4b9663 + SIOCGLIFGROUPNAME = -0x3f879664 + SIOCGLIFHWADDR = -0x3f879640 + SIOCGLIFINDEX = -0x3f87967b + SIOCGLIFLNKINFO = -0x3f879674 + SIOCGLIFMETRIC = -0x3f879681 + SIOCGLIFMTU = -0x3f879686 + SIOCGLIFMUXID = -0x3f87967d + SIOCGLIFNETMASK = -0x3f879683 + SIOCGLIFNUM = -0x3ff3967e + SIOCGLIFSRCOF = -0x3fef964f + SIOCGLIFSUBNET = -0x3f879676 + SIOCGLIFTOKEN = -0x3f879678 + SIOCGLIFUSESRC = -0x3f879651 + SIOCGLIFZONE = -0x3f879656 + SIOCGLOWAT = 0x40047303 + SIOCGMSFILTER = -0x3ffb964e + SIOCGPGRP = 0x40047309 + SIOCGSTAMP = -0x3fef9646 + SIOCGXARP = -0x3fff9659 + SIOCIFDETACH = -0x7fdf96c8 + SIOCILB = -0x3ffb9645 + SIOCLIFADDIF = -0x3f879691 + SIOCLIFDELND = -0x7f879673 + SIOCLIFGETND = -0x3f879672 + SIOCLIFREMOVEIF = -0x7f879692 + SIOCLIFSETND = -0x7f879671 + SIOCLIPSECONFIG = -0x7ffb9668 + SIOCLOWER = -0x7fdf96d7 + SIOCSARP = -0x7fdb96e2 + SIOCSCTPGOPT = -0x3fef9653 + SIOCSCTPPEELOFF = -0x3ffb9652 + SIOCSCTPSOPT = -0x7fef9654 + SIOCSENABLESDP = -0x3ffb9649 + SIOCSETPROP = -0x7ffb8f43 + SIOCSETSYNC = -0x7fdf96d4 + SIOCSHIWAT = -0x7ffb8d00 + SIOCSIFADDR = -0x7fdf96f4 + SIOCSIFBRDADDR = -0x7fdf96e8 + SIOCSIFDSTADDR = -0x7fdf96f2 + SIOCSIFFLAGS = -0x7fdf96f0 + SIOCSIFINDEX = -0x7fdf96a5 + SIOCSIFMEM = -0x7fdf96ee + SIOCSIFMETRIC = -0x7fdf96e4 + SIOCSIFMTU = -0x7fdf96eb + SIOCSIFMUXID = -0x7fdf96a7 + SIOCSIFNAME = -0x7fdf96b7 + SIOCSIFNETMASK = -0x7fdf96e6 + SIOCSIP6ADDRPOLICY = -0x7fff965d + SIOCSIPMSFILTER = -0x7ffb964b + SIOCSIPSECONFIG = -0x7ffb966a + SIOCSLGETREQ = -0x3fdf96b9 + SIOCSLIFADDR = -0x7f879690 + SIOCSLIFBRDADDR = -0x7f879684 + SIOCSLIFDSTADDR = -0x7f87968e + SIOCSLIFFLAGS = -0x7f87968c + SIOCSLIFGROUPNAME = -0x7f879665 + SIOCSLIFINDEX = -0x7f87967a + SIOCSLIFLNKINFO = -0x7f879675 + SIOCSLIFMETRIC = -0x7f879680 + SIOCSLIFMTU = -0x7f879687 + SIOCSLIFMUXID = -0x7f87967c + SIOCSLIFNAME = -0x3f87967f + SIOCSLIFNETMASK = -0x7f879682 + SIOCSLIFPREFIX = -0x3f879641 + SIOCSLIFSUBNET = -0x7f879677 + SIOCSLIFTOKEN = -0x7f879679 + SIOCSLIFUSESRC = -0x7f879650 + SIOCSLIFZONE = -0x7f879655 + SIOCSLOWAT = -0x7ffb8cfe + SIOCSLSTAT = -0x7fdf96b8 + SIOCSMSFILTER = -0x7ffb964d + SIOCSPGRP = -0x7ffb8cf8 + SIOCSPROMISC = -0x7ffb96d0 + SIOCSQPTR = -0x3ffb9648 + SIOCSSDSTATS = -0x3fdf96d2 + SIOCSSESTATS = -0x3fdf96d1 + SIOCSXARP = -0x7fff965a + SIOCTMYADDR = -0x3ff79670 + SIOCTMYSITE = -0x3ff7966e + SIOCTONLINK = -0x3ff7966f + SIOCUPPER = -0x7fdf96d8 + SIOCX25RCV = -0x3fdf96c4 + SIOCX25TBL = -0x3fdf96c3 + SIOCX25XMT = -0x3fdf96c5 + SIOCXPROTO = 0x20007337 + SOCK_CLOEXEC = 0x80000 + SOCK_DGRAM = 0x1 + SOCK_NDELAY = 0x200000 + SOCK_NONBLOCK = 0x100000 + SOCK_RAW = 0x4 + SOCK_RDM = 0x5 + SOCK_SEQPACKET = 0x6 + SOCK_STREAM = 0x2 + SOCK_TYPE_MASK = 0xffff + SOL_FILTER = 0xfffc + SOL_PACKET = 0xfffd + SOL_ROUTE = 0xfffe + SOL_SOCKET = 0xffff + SOMAXCONN = 0x80 + SO_ACCEPTCONN = 0x2 + SO_ALL = 0x3f + SO_ALLZONES = 0x1014 + SO_ANON_MLP = 0x100a + SO_ATTACH_FILTER = 0x40000001 + SO_BAND = 0x4000 + SO_BROADCAST = 0x20 + SO_COPYOPT = 0x80000 + SO_DEBUG = 0x1 + SO_DELIM = 0x8000 + SO_DETACH_FILTER = 0x40000002 + SO_DGRAM_ERRIND = 0x200 + SO_DOMAIN = 0x100c + SO_DONTLINGER = -0x81 + SO_DONTROUTE = 0x10 + SO_ERROPT = 0x40000 + SO_ERROR = 0x1007 + SO_EXCLBIND = 0x1015 + SO_HIWAT = 0x10 + SO_ISNTTY = 0x800 + SO_ISTTY = 0x400 + SO_KEEPALIVE = 0x8 + SO_LINGER = 0x80 + SO_LOWAT = 0x20 + SO_MAC_EXEMPT = 0x100b + SO_MAC_IMPLICIT = 0x1016 + SO_MAXBLK = 0x100000 + SO_MAXPSZ = 0x8 + SO_MINPSZ = 0x4 + SO_MREADOFF = 0x80 + SO_MREADON = 0x40 + SO_NDELOFF = 0x200 + SO_NDELON = 0x100 + SO_NODELIM = 0x10000 + SO_OOBINLINE = 0x100 + SO_PROTOTYPE = 0x1009 + SO_RCVBUF = 0x1002 + SO_RCVLOWAT = 0x1004 + SO_RCVPSH = 0x100d + SO_RCVTIMEO = 0x1006 + SO_READOPT = 0x1 + SO_RECVUCRED = 0x400 + SO_REUSEADDR = 0x4 + SO_SECATTR = 0x1011 + SO_SNDBUF = 0x1001 + SO_SNDLOWAT = 0x1003 + SO_SNDTIMEO = 0x1005 + SO_STRHOLD = 0x20000 + SO_TAIL = 0x200000 + SO_TIMESTAMP = 0x1013 + SO_TONSTOP = 0x2000 + SO_TOSTOP = 0x1000 + SO_TYPE = 0x1008 + SO_USELOOPBACK = 0x40 + SO_VRRP = 0x1017 + SO_WROFF = 0x2 + TCFLSH = 0x5407 + TCIFLUSH = 0x0 + TCIOFLUSH = 0x2 + TCOFLUSH = 0x1 + TCP_ABORT_THRESHOLD = 0x11 + TCP_ANONPRIVBIND = 0x20 + TCP_CONN_ABORT_THRESHOLD = 0x13 + TCP_CONN_NOTIFY_THRESHOLD = 0x12 + TCP_CORK = 0x18 + TCP_EXCLBIND = 0x21 + TCP_INIT_CWND = 0x15 + TCP_KEEPALIVE = 0x8 + TCP_KEEPALIVE_ABORT_THRESHOLD = 0x17 + TCP_KEEPALIVE_THRESHOLD = 0x16 + TCP_KEEPCNT = 0x23 + TCP_KEEPIDLE = 0x22 + TCP_KEEPINTVL = 0x24 + TCP_LINGER2 = 0x1c + TCP_MAXSEG = 0x2 + TCP_MSS = 0x218 + TCP_NODELAY = 0x1 + TCP_NOTIFY_THRESHOLD = 0x10 + TCP_RECVDSTADDR = 0x14 + TCP_RTO_INITIAL = 0x19 + TCP_RTO_MAX = 0x1b + TCP_RTO_MIN = 0x1a + TCSAFLUSH = 0x5410 + TIOC = 0x5400 + TIOCCBRK = 0x747a + TIOCCDTR = 0x7478 + TIOCCILOOP = 0x746c + TIOCEXCL = 0x740d + TIOCFLUSH = 0x7410 + TIOCGETC = 0x7412 + TIOCGETD = 0x7400 + TIOCGETP = 0x7408 + TIOCGLTC = 0x7474 + TIOCGPGRP = 0x7414 + TIOCGPPS = 0x547d + TIOCGPPSEV = 0x547f + TIOCGSID = 0x7416 + TIOCGSOFTCAR = 0x5469 + TIOCGWINSZ = 0x5468 + TIOCHPCL = 0x7402 + TIOCKBOF = 0x5409 + TIOCKBON = 0x5408 + TIOCLBIC = 0x747e + TIOCLBIS = 0x747f + TIOCLGET = 0x747c + TIOCLSET = 0x747d + TIOCMBIC = 0x741c + TIOCMBIS = 0x741b + TIOCMGET = 0x741d + TIOCMSET = 0x741a + TIOCM_CAR = 0x40 + TIOCM_CD = 0x40 + TIOCM_CTS = 0x20 + TIOCM_DSR = 0x100 + TIOCM_DTR = 0x2 + TIOCM_LE = 0x1 + TIOCM_RI = 0x80 + TIOCM_RNG = 0x80 + TIOCM_RTS = 0x4 + TIOCM_SR = 0x10 + TIOCM_ST = 0x8 + TIOCNOTTY = 0x7471 + TIOCNXCL = 0x740e + TIOCOUTQ = 0x7473 + TIOCREMOTE = 0x741e + TIOCSBRK = 0x747b + TIOCSCTTY = 0x7484 + TIOCSDTR = 0x7479 + TIOCSETC = 0x7411 + TIOCSETD = 0x7401 + TIOCSETN = 0x740a + TIOCSETP = 0x7409 + TIOCSIGNAL = 0x741f + TIOCSILOOP = 0x746d + TIOCSLTC = 0x7475 + TIOCSPGRP = 0x7415 + TIOCSPPS = 0x547e + TIOCSSOFTCAR = 0x546a + TIOCSTART = 0x746e + TIOCSTI = 0x7417 + TIOCSTOP = 0x746f + TIOCSWINSZ = 0x5467 + TOSTOP = 0x100 + VCEOF = 0x8 + VCEOL = 0x9 + VDISCARD = 0xd + VDSUSP = 0xb + VEOF = 0x4 + VEOL = 0x5 + VEOL2 = 0x6 + VERASE = 0x2 + VINTR = 0x0 + VKILL = 0x3 + VLNEXT = 0xf + VMIN = 0x4 + VQUIT = 0x1 + VREPRINT = 0xc + VSTART = 0x8 + VSTOP = 0x9 + VSUSP = 0xa + VSWTCH = 0x7 + VT0 = 0x0 + VT1 = 0x4000 + VTDLY = 0x4000 + VTIME = 0x5 + VWERASE = 0xe + WCONTFLG = 0xffff + WCONTINUED = 0x8 + WCOREFLG = 0x80 + WEXITED = 0x1 + WNOHANG = 0x40 + WNOWAIT = 0x80 + WOPTMASK = 0xcf + WRAP = 0x20000 + WSIGMASK = 0x7f + WSTOPFLG = 0x7f + WSTOPPED = 0x4 + WTRAPPED = 0x2 + WUNTRACED = 0x4 +) + +// Errors +const ( + E2BIG = Errno(0x7) + EACCES = Errno(0xd) + EADDRINUSE = Errno(0x7d) + EADDRNOTAVAIL = Errno(0x7e) + EADV = Errno(0x44) + EAFNOSUPPORT = Errno(0x7c) + EAGAIN = Errno(0xb) + EALREADY = Errno(0x95) + EBADE = Errno(0x32) + EBADF = Errno(0x9) + EBADFD = Errno(0x51) + EBADMSG = Errno(0x4d) + EBADR = Errno(0x33) + EBADRQC = Errno(0x36) + EBADSLT = Errno(0x37) + EBFONT = Errno(0x39) + EBUSY = Errno(0x10) + ECANCELED = Errno(0x2f) + ECHILD = Errno(0xa) + ECHRNG = Errno(0x25) + ECOMM = Errno(0x46) + ECONNABORTED = Errno(0x82) + ECONNREFUSED = Errno(0x92) + ECONNRESET = Errno(0x83) + EDEADLK = Errno(0x2d) + EDEADLOCK = Errno(0x38) + EDESTADDRREQ = Errno(0x60) + EDOM = Errno(0x21) + EDQUOT = Errno(0x31) + EEXIST = Errno(0x11) + EFAULT = Errno(0xe) + EFBIG = Errno(0x1b) + EHOSTDOWN = Errno(0x93) + EHOSTUNREACH = Errno(0x94) + EIDRM = Errno(0x24) + EILSEQ = Errno(0x58) + EINPROGRESS = Errno(0x96) + EINTR = Errno(0x4) + EINVAL = Errno(0x16) + EIO = Errno(0x5) + EISCONN = Errno(0x85) + EISDIR = Errno(0x15) + EL2HLT = Errno(0x2c) + EL2NSYNC = Errno(0x26) + EL3HLT = Errno(0x27) + EL3RST = Errno(0x28) + ELIBACC = Errno(0x53) + ELIBBAD = Errno(0x54) + ELIBEXEC = Errno(0x57) + ELIBMAX = Errno(0x56) + ELIBSCN = Errno(0x55) + ELNRNG = Errno(0x29) + ELOCKUNMAPPED = Errno(0x48) + ELOOP = Errno(0x5a) + EMFILE = Errno(0x18) + EMLINK = Errno(0x1f) + EMSGSIZE = Errno(0x61) + EMULTIHOP = Errno(0x4a) + ENAMETOOLONG = Errno(0x4e) + ENETDOWN = Errno(0x7f) + ENETRESET = Errno(0x81) + ENETUNREACH = Errno(0x80) + ENFILE = Errno(0x17) + ENOANO = Errno(0x35) + ENOBUFS = Errno(0x84) + ENOCSI = Errno(0x2b) + ENODATA = Errno(0x3d) + ENODEV = Errno(0x13) + ENOENT = Errno(0x2) + ENOEXEC = Errno(0x8) + ENOLCK = Errno(0x2e) + ENOLINK = Errno(0x43) + ENOMEM = Errno(0xc) + ENOMSG = Errno(0x23) + ENONET = Errno(0x40) + ENOPKG = Errno(0x41) + ENOPROTOOPT = Errno(0x63) + ENOSPC = Errno(0x1c) + ENOSR = Errno(0x3f) + ENOSTR = Errno(0x3c) + ENOSYS = Errno(0x59) + ENOTACTIVE = Errno(0x49) + ENOTBLK = Errno(0xf) + ENOTCONN = Errno(0x86) + ENOTDIR = Errno(0x14) + ENOTEMPTY = Errno(0x5d) + ENOTRECOVERABLE = Errno(0x3b) + ENOTSOCK = Errno(0x5f) + ENOTSUP = Errno(0x30) + ENOTTY = Errno(0x19) + ENOTUNIQ = Errno(0x50) + ENXIO = Errno(0x6) + EOPNOTSUPP = Errno(0x7a) + EOVERFLOW = Errno(0x4f) + EOWNERDEAD = Errno(0x3a) + EPERM = Errno(0x1) + EPFNOSUPPORT = Errno(0x7b) + EPIPE = Errno(0x20) + EPROTO = Errno(0x47) + EPROTONOSUPPORT = Errno(0x78) + EPROTOTYPE = Errno(0x62) + ERANGE = Errno(0x22) + EREMCHG = Errno(0x52) + EREMOTE = Errno(0x42) + ERESTART = Errno(0x5b) + EROFS = Errno(0x1e) + ESHUTDOWN = Errno(0x8f) + ESOCKTNOSUPPORT = Errno(0x79) + ESPIPE = Errno(0x1d) + ESRCH = Errno(0x3) + ESRMNT = Errno(0x45) + ESTALE = Errno(0x97) + ESTRPIPE = Errno(0x5c) + ETIME = Errno(0x3e) + ETIMEDOUT = Errno(0x91) + ETOOMANYREFS = Errno(0x90) + ETXTBSY = Errno(0x1a) + EUNATCH = Errno(0x2a) + EUSERS = Errno(0x5e) + EWOULDBLOCK = Errno(0xb) + EXDEV = Errno(0x12) + EXFULL = Errno(0x34) +) + +// Signals +const ( + SIGABRT = Signal(0x6) + SIGALRM = Signal(0xe) + SIGBUS = Signal(0xa) + SIGCANCEL = Signal(0x24) + SIGCHLD = Signal(0x12) + SIGCLD = Signal(0x12) + SIGCONT = Signal(0x19) + SIGEMT = Signal(0x7) + SIGFPE = Signal(0x8) + SIGFREEZE = Signal(0x22) + SIGHUP = Signal(0x1) + SIGILL = Signal(0x4) + SIGINT = Signal(0x2) + SIGIO = Signal(0x16) + SIGIOT = Signal(0x6) + SIGJVM1 = Signal(0x27) + SIGJVM2 = Signal(0x28) + SIGKILL = Signal(0x9) + SIGLOST = Signal(0x25) + SIGLWP = Signal(0x21) + SIGPIPE = Signal(0xd) + SIGPOLL = Signal(0x16) + SIGPROF = Signal(0x1d) + SIGPWR = Signal(0x13) + SIGQUIT = Signal(0x3) + SIGSEGV = Signal(0xb) + SIGSTOP = Signal(0x17) + SIGSYS = Signal(0xc) + SIGTERM = Signal(0xf) + SIGTHAW = Signal(0x23) + SIGTRAP = Signal(0x5) + SIGTSTP = Signal(0x18) + SIGTTIN = Signal(0x1a) + SIGTTOU = Signal(0x1b) + SIGURG = Signal(0x15) + SIGUSR1 = Signal(0x10) + SIGUSR2 = Signal(0x11) + SIGVTALRM = Signal(0x1c) + SIGWAITING = Signal(0x20) + SIGWINCH = Signal(0x14) + SIGXCPU = Signal(0x1e) + SIGXFSZ = Signal(0x1f) + SIGXRES = Signal(0x26) +) + +// Error table +var errors = [...]string{ + 1: "not owner", + 2: "no such file or directory", + 3: "no such process", + 4: "interrupted system call", + 5: "I/O error", + 6: "no such device or address", + 7: "arg list too long", + 8: "exec format error", + 9: "bad file number", + 10: "no child processes", + 11: "resource temporarily unavailable", + 12: "not enough space", + 13: "permission denied", + 14: "bad address", + 15: "block device required", + 16: "device busy", + 17: "file exists", + 18: "cross-device link", + 19: "no such device", + 20: "not a directory", + 21: "is a directory", + 22: "invalid argument", + 23: "file table overflow", + 24: "too many open files", + 25: "inappropriate ioctl for device", + 26: "text file busy", + 27: "file too large", + 28: "no space left on device", + 29: "illegal seek", + 30: "read-only file system", + 31: "too many links", + 32: "broken pipe", + 33: "argument out of domain", + 34: "result too large", + 35: "no message of desired type", + 36: "identifier removed", + 37: "channel number out of range", + 38: "level 2 not synchronized", + 39: "level 3 halted", + 40: "level 3 reset", + 41: "link number out of range", + 42: "protocol driver not attached", + 43: "no CSI structure available", + 44: "level 2 halted", + 45: "deadlock situation detected/avoided", + 46: "no record locks available", + 47: "operation canceled", + 48: "operation not supported", + 49: "disc quota exceeded", + 50: "bad exchange descriptor", + 51: "bad request descriptor", + 52: "message tables full", + 53: "anode table overflow", + 54: "bad request code", + 55: "invalid slot", + 56: "file locking deadlock", + 57: "bad font file format", + 58: "owner of the lock died", + 59: "lock is not recoverable", + 60: "not a stream device", + 61: "no data available", + 62: "timer expired", + 63: "out of stream resources", + 64: "machine is not on the network", + 65: "package not installed", + 66: "object is remote", + 67: "link has been severed", + 68: "advertise error", + 69: "srmount error", + 70: "communication error on send", + 71: "protocol error", + 72: "locked lock was unmapped ", + 73: "facility is not active", + 74: "multihop attempted", + 77: "not a data message", + 78: "file name too long", + 79: "value too large for defined data type", + 80: "name not unique on network", + 81: "file descriptor in bad state", + 82: "remote address changed", + 83: "can not access a needed shared library", + 84: "accessing a corrupted shared library", + 85: ".lib section in a.out corrupted", + 86: "attempting to link in more shared libraries than system limit", + 87: "can not exec a shared library directly", + 88: "illegal byte sequence", + 89: "operation not applicable", + 90: "number of symbolic links encountered during path name traversal exceeds MAXSYMLINKS", + 91: "error 91", + 92: "error 92", + 93: "directory not empty", + 94: "too many users", + 95: "socket operation on non-socket", + 96: "destination address required", + 97: "message too long", + 98: "protocol wrong type for socket", + 99: "option not supported by protocol", + 120: "protocol not supported", + 121: "socket type not supported", + 122: "operation not supported on transport endpoint", + 123: "protocol family not supported", + 124: "address family not supported by protocol family", + 125: "address already in use", + 126: "cannot assign requested address", + 127: "network is down", + 128: "network is unreachable", + 129: "network dropped connection because of reset", + 130: "software caused connection abort", + 131: "connection reset by peer", + 132: "no buffer space available", + 133: "transport endpoint is already connected", + 134: "transport endpoint is not connected", + 143: "cannot send after socket shutdown", + 144: "too many references: cannot splice", + 145: "connection timed out", + 146: "connection refused", + 147: "host is down", + 148: "no route to host", + 149: "operation already in progress", + 150: "operation now in progress", + 151: "stale NFS file handle", +} + +// Signal table +var signals = [...]string{ + 1: "hangup", + 2: "interrupt", + 3: "quit", + 4: "illegal Instruction", + 5: "trace/Breakpoint Trap", + 6: "abort", + 7: "emulation Trap", + 8: "arithmetic Exception", + 9: "killed", + 10: "bus Error", + 11: "segmentation Fault", + 12: "bad System Call", + 13: "broken Pipe", + 14: "alarm Clock", + 15: "terminated", + 16: "user Signal 1", + 17: "user Signal 2", + 18: "child Status Changed", + 19: "power-Fail/Restart", + 20: "window Size Change", + 21: "urgent Socket Condition", + 22: "pollable Event", + 23: "stopped (signal)", + 24: "stopped (user)", + 25: "continued", + 26: "stopped (tty input)", + 27: "stopped (tty output)", + 28: "virtual Timer Expired", + 29: "profiling Timer Expired", + 30: "cpu Limit Exceeded", + 31: "file Size Limit Exceeded", + 32: "no runnable lwp", + 33: "inter-lwp signal", + 34: "checkpoint Freeze", + 35: "checkpoint Thaw", + 36: "thread Cancellation", + 37: "resource Lost", + 38: "resource Control Exceeded", + 39: "reserved for JVM 1", + 40: "reserved for JVM 2", +} diff --git a/src/pkg/syscall/zsyscall_darwin_386.go b/src/pkg/syscall/zsyscall_darwin_386.go index 98500792d..a6a176b60 100644 --- a/src/pkg/syscall/zsyscall_darwin_386.go +++ b/src/pkg/syscall/zsyscall_darwin_386.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -590,23 +591,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT64, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) @@ -824,6 +808,74 @@ func Mknod(path string, mode uint32, dev int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func Mlock(b []byte) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Mlockall(flags int) (err error) { + _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Mprotect(b []byte, prot int) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot)) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Munlock(b []byte) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Munlockall() (err error) { + _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Open(path string, mode int, perm uint32) (fd int, err error) { var _p0 *byte _p0, err = BytePtrFromString(path) diff --git a/src/pkg/syscall/zsyscall_darwin_amd64.go b/src/pkg/syscall/zsyscall_darwin_amd64.go index ee810e076..f5867c45d 100644 --- a/src/pkg/syscall/zsyscall_darwin_amd64.go +++ b/src/pkg/syscall/zsyscall_darwin_amd64.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -590,23 +591,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT64, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) @@ -824,6 +808,74 @@ func Mknod(path string, mode uint32, dev int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func Mlock(b []byte) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Mlockall(flags int) (err error) { + _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Mprotect(b []byte, prot int) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot)) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Munlock(b []byte) (err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Munlockall() (err error) { + _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Open(path string, mode int, perm uint32) (fd int, err error) { var _p0 *byte _p0, err = BytePtrFromString(path) diff --git a/src/pkg/syscall/zsyscall_dragonfly_386.go b/src/pkg/syscall/zsyscall_dragonfly_386.go index 5c3fe0713..0ec813232 100644 --- a/src/pkg/syscall/zsyscall_dragonfly_386.go +++ b/src/pkg/syscall/zsyscall_dragonfly_386.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -584,23 +585,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) diff --git a/src/pkg/syscall/zsyscall_dragonfly_amd64.go b/src/pkg/syscall/zsyscall_dragonfly_amd64.go index c7766a8c3..8c7cce54e 100644 --- a/src/pkg/syscall/zsyscall_dragonfly_amd64.go +++ b/src/pkg/syscall/zsyscall_dragonfly_amd64.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -584,23 +585,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) diff --git a/src/pkg/syscall/zsyscall_freebsd_386.go b/src/pkg/syscall/zsyscall_freebsd_386.go index 631994fba..5befe83c6 100644 --- a/src/pkg/syscall/zsyscall_freebsd_386.go +++ b/src/pkg/syscall/zsyscall_freebsd_386.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -550,23 +551,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) @@ -1301,3 +1285,14 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) { } return } + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) { + r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0) + nfd = int(r0) + if e1 != 0 { + err = e1 + } + return +} diff --git a/src/pkg/syscall/zsyscall_freebsd_amd64.go b/src/pkg/syscall/zsyscall_freebsd_amd64.go index 1d5180853..ab2eb80c6 100644 --- a/src/pkg/syscall/zsyscall_freebsd_amd64.go +++ b/src/pkg/syscall/zsyscall_freebsd_amd64.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -550,23 +551,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) @@ -1301,3 +1285,14 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) { } return } + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) { + r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0) + nfd = int(r0) + if e1 != 0 { + err = e1 + } + return +} diff --git a/src/pkg/syscall/zsyscall_freebsd_arm.go b/src/pkg/syscall/zsyscall_freebsd_arm.go index 925b83fbb..c1f0f907c 100644 --- a/src/pkg/syscall/zsyscall_freebsd_arm.go +++ b/src/pkg/syscall/zsyscall_freebsd_arm.go @@ -1,4 +1,4 @@ -// mksyscall.pl -l32 syscall_bsd.go syscall_freebsd.go syscall_freebsd_386.go +// mksyscall.pl -l32 -arm syscall_bsd.go syscall_freebsd.go syscall_freebsd_arm.go // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT package syscall @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -418,13 +419,8 @@ func Fchdir(fd int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Fchflags(path string, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) +func Fchflags(fd int, flags int) (err error) { + _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0) if e1 != 0 { err = e1 } @@ -505,7 +501,7 @@ func Fsync(fd int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Ftruncate(fd int, length int64) (err error) { - _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), uintptr(length>>32)) + _, _, e1 := Syscall6(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length), uintptr(length>>32), 0, 0) if e1 != 0 { err = e1 } @@ -555,23 +551,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) @@ -858,7 +837,7 @@ func Pread(fd int, p []byte, offset int64) (n int, err error) { } else { _p0 = unsafe.Pointer(&_zero) } - r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0) + r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32)) n = int(r0) if e1 != 0 { err = e1 @@ -875,7 +854,24 @@ func Pwrite(fd int, p []byte, offset int64) (n int, err error) { } else { _p0 = unsafe.Pointer(&_zero) } - r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0) + r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), uintptr(offset>>32)) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func read(fd int, p []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(p) > 0 { + _p0 = unsafe.Pointer(&p[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p))) n = int(r0) if e1 != 0 { err = e1 @@ -958,7 +954,7 @@ func Rmdir(path string) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { - r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0) + r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(whence), 0) newoffset = int64(int64(r1)<<32 | int64(r0)) if e1 != 0 { err = e1 @@ -1170,7 +1166,7 @@ func Truncate(path string, length int64) (err error) { if err != nil { return } - _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32)) + _, _, e1 := Syscall6(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length), uintptr(length>>32), 0, 0) if e1 != 0 { err = e1 } @@ -1232,9 +1228,15 @@ func Unmount(path string, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { - r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0) - ret = uintptr(r0) +func write(fd int, p []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(p) > 0 { + _p0 = unsafe.Pointer(&p[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p))) + n = int(r0) if e1 != 0 { err = e1 } @@ -1243,8 +1245,9 @@ func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) ( // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func munmap(addr uintptr, length uintptr) (err error) { - _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0) +func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { + r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), uintptr(pos>>32), 0) + ret = uintptr(r0) if e1 != 0 { err = e1 } @@ -1253,15 +1256,8 @@ func munmap(addr uintptr, length uintptr) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func read(fd int, p []byte) (n int, err error) { - var _p0 unsafe.Pointer - if len(p) > 0 { - _p0 = unsafe.Pointer(&p[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p))) - n = int(r0) +func munmap(addr uintptr, length uintptr) (err error) { + _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0) if e1 != 0 { err = e1 } @@ -1270,14 +1266,8 @@ func read(fd int, p []byte) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func write(fd int, p []byte) (n int, err error) { - var _p0 unsafe.Pointer - if len(p) > 0 { - _p0 = unsafe.Pointer(&p[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p))) +func readlen(fd int, buf *byte, nbuf int) (n int, err error) { + r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) n = int(r0) if e1 != 0 { err = e1 @@ -1287,8 +1277,8 @@ func write(fd int, p []byte) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func readlen(fd int, buf *byte, nbuf int) (n int, err error) { - r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) +func writelen(fd int, buf *byte, nbuf int) (n int, err error) { + r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) n = int(r0) if e1 != 0 { err = e1 @@ -1298,9 +1288,9 @@ func readlen(fd int, buf *byte, nbuf int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func writelen(fd int, buf *byte, nbuf int) (n int, err error) { - r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) - n = int(r0) +func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) { + r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0) + nfd = int(r0) if e1 != 0 { err = e1 } diff --git a/src/pkg/syscall/zsyscall_linux_amd64.go b/src/pkg/syscall/zsyscall_linux_amd64.go index c1c3d4511..c65448e21 100644 --- a/src/pkg/syscall/zsyscall_linux_amd64.go +++ b/src/pkg/syscall/zsyscall_linux_amd64.go @@ -1763,7 +1763,7 @@ func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -1773,7 +1773,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -1804,7 +1804,7 @@ func setgroups(n int, list *_Gid_t) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -1814,7 +1814,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -1882,7 +1882,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -1909,8 +1909,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } diff --git a/src/pkg/syscall/zsyscall_linux_arm.go b/src/pkg/syscall/zsyscall_linux_arm.go index 3380714a6..a970ce6dc 100644 --- a/src/pkg/syscall/zsyscall_linux_arm.go +++ b/src/pkg/syscall/zsyscall_linux_arm.go @@ -1383,7 +1383,7 @@ func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -1393,7 +1393,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -1424,7 +1424,7 @@ func setgroups(n int, list *_Gid_t) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -1434,7 +1434,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -1492,7 +1492,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -1529,8 +1529,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } diff --git a/src/pkg/syscall/zsyscall_nacl_386.go b/src/pkg/syscall/zsyscall_nacl_386.go new file mode 100644 index 000000000..32eed339a --- /dev/null +++ b/src/pkg/syscall/zsyscall_nacl_386.go @@ -0,0 +1,63 @@ +// mksyscall.pl -l32 -nacl syscall_nacl.go syscall_nacl_386.go +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +package syscall + +import "unsafe" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclClose(fd int) (err error) { + _, _, e1 := Syscall(sys_close, uintptr(fd), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Exit(code int) (err error) { + _, _, e1 := Syscall(sys_exit, uintptr(code), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclFstat(fd int, stat *Stat_t) (err error) { + _, _, e1 := Syscall(sys_fstat, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclRead(fd int, b []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := Syscall(sys_read, uintptr(fd), uintptr(_p0), uintptr(len(b))) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclSeek(fd int, off *int64, whence int) (err error) { + _, _, e1 := Syscall(sys_lseek, uintptr(fd), uintptr(unsafe.Pointer(off)), uintptr(whence)) + if e1 != 0 { + err = e1 + } + return +} diff --git a/src/pkg/syscall/zsyscall_nacl_amd64p32.go b/src/pkg/syscall/zsyscall_nacl_amd64p32.go new file mode 100644 index 000000000..8bc81fac9 --- /dev/null +++ b/src/pkg/syscall/zsyscall_nacl_amd64p32.go @@ -0,0 +1,63 @@ +// mksyscall.pl -nacl syscall_nacl.go syscall_nacl_amd64p32.go +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +package syscall + +import "unsafe" + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclClose(fd int) (err error) { + _, _, e1 := Syscall(sys_close, uintptr(fd), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func Exit(code int) (err error) { + _, _, e1 := Syscall(sys_exit, uintptr(code), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclFstat(fd int, stat *Stat_t) (err error) { + _, _, e1 := Syscall(sys_fstat, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclRead(fd int, b []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(b) > 0 { + _p0 = unsafe.Pointer(&b[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := Syscall(sys_read, uintptr(fd), uintptr(_p0), uintptr(len(b))) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func naclSeek(fd int, off *int64, whence int) (err error) { + _, _, e1 := Syscall(sys_lseek, uintptr(fd), uintptr(unsafe.Pointer(off)), uintptr(whence)) + if e1 != 0 { + err = e1 + } + return +} diff --git a/src/pkg/syscall/zsyscall_netbsd_386.go b/src/pkg/syscall/zsyscall_netbsd_386.go index 0ee19bee1..281208f41 100644 --- a/src/pkg/syscall/zsyscall_netbsd_386.go +++ b/src/pkg/syscall/zsyscall_netbsd_386.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { diff --git a/src/pkg/syscall/zsyscall_netbsd_amd64.go b/src/pkg/syscall/zsyscall_netbsd_amd64.go index b9d272144..ed9a87df6 100644 --- a/src/pkg/syscall/zsyscall_netbsd_amd64.go +++ b/src/pkg/syscall/zsyscall_netbsd_amd64.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { diff --git a/src/pkg/syscall/zsyscall_netbsd_arm.go b/src/pkg/syscall/zsyscall_netbsd_arm.go index 763a906e5..c5c9a9f2c 100644 --- a/src/pkg/syscall/zsyscall_netbsd_arm.go +++ b/src/pkg/syscall/zsyscall_netbsd_arm.go @@ -1,4 +1,4 @@ -// mksyscall.pl -l32 -netbsd syscall_bsd.go syscall_netbsd.go syscall_netbsd_arm.go +// mksyscall.pl -l32 -arm syscall_bsd.go syscall_netbsd.go syscall_netbsd_arm.go // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT package syscall @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -435,13 +436,8 @@ func Fchdir(fd int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Fchflags(path string, flags int) (err error) { - var _p0 *byte - _p0, err = BytePtrFromString(path) - if err != nil { - return - } - _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) +func Fchflags(fd int, flags int) (err error) { + _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0) if e1 != 0 { err = e1 } diff --git a/src/pkg/syscall/zsyscall_openbsd_386.go b/src/pkg/syscall/zsyscall_openbsd_386.go index 2c2a56732..785e7c3b8 100644 --- a/src/pkg/syscall/zsyscall_openbsd_386.go +++ b/src/pkg/syscall/zsyscall_openbsd_386.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -268,6 +269,23 @@ func pipe(p *[2]_C_int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func getdents(fd int, buf []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf))) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Access(path string, mode uint32) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) @@ -507,23 +525,6 @@ func Ftruncate(fd int, length int64) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall6(SYS_GETDIRENTRIES, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getegid() (egid int) { r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0) egid = int(r0) @@ -540,23 +541,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) diff --git a/src/pkg/syscall/zsyscall_openbsd_amd64.go b/src/pkg/syscall/zsyscall_openbsd_amd64.go index 4e1470696..7a8d9b6f1 100644 --- a/src/pkg/syscall/zsyscall_openbsd_amd64.go +++ b/src/pkg/syscall/zsyscall_openbsd_amd64.go @@ -50,7 +50,7 @@ func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func bind(s int, addr uintptr, addrlen _Socklen) (err error) { +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -60,7 +60,7 @@ func bind(s int, addr uintptr, addrlen _Socklen) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func connect(s int, addr uintptr, addrlen _Socklen) (err error) { +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) if e1 != 0 { err = e1 @@ -81,7 +81,7 @@ func socket(domain int, typ int, proto int) (fd int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) { +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) if e1 != 0 { err = e1 @@ -91,7 +91,7 @@ func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) { +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) if e1 != 0 { err = e1 @@ -158,7 +158,7 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) { +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { var _p0 unsafe.Pointer if len(buf) > 0 { _p0 = unsafe.Pointer(&buf[0]) @@ -185,8 +185,9 @@ func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func sendmsg(s int, msg *Msghdr, flags int) (err error) { - _, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) + n = int(r0) if e1 != 0 { err = e1 } @@ -195,7 +196,7 @@ func sendmsg(s int, msg *Msghdr, flags int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, err error) { +func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) n = int(r0) if e1 != 0 { @@ -268,6 +269,23 @@ func pipe(p *[2]_C_int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func getdents(fd int, buf []byte) (n int, err error) { + var _p0 unsafe.Pointer + if len(buf) > 0 { + _p0 = unsafe.Pointer(&buf[0]) + } else { + _p0 = unsafe.Pointer(&_zero) + } + r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf))) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Access(path string, mode uint32) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) @@ -507,23 +525,6 @@ func Ftruncate(fd int, length int64) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall6(SYS_GETDIRENTRIES, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getegid() (egid int) { r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0) egid = int(r0) @@ -540,23 +541,6 @@ func Geteuid() (uid int) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Getfsstat(buf []Statfs_t, flags int) (n int, err error) { - var _p0 unsafe.Pointer - if len(buf) > 0 { - _p0 = unsafe.Pointer(&buf[0]) - } else { - _p0 = unsafe.Pointer(&_zero) - } - r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) - n = int(r0) - if e1 != 0 { - err = e1 - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getgid() (gid int) { r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) gid = int(r0) diff --git a/src/pkg/syscall/zsyscall_solaris_amd64.go b/src/pkg/syscall/zsyscall_solaris_amd64.go new file mode 100644 index 000000000..8847cad01 --- /dev/null +++ b/src/pkg/syscall/zsyscall_solaris_amd64.go @@ -0,0 +1,883 @@ +// mksyscall_solaris.pl syscall_solaris.go syscall_solaris_amd64.go +// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT + +package syscall + +import "unsafe" + +var ( + modlibc = newLazySO("libc.so") + modlibsocket = newLazySO("libsocket.so") + + procgetgroups = modlibc.NewProc("getgroups") + procsetgroups = modlibc.NewProc("setgroups") + procfcntl = modlibc.NewProc("fcntl") + procaccept = modlibsocket.NewProc("accept") + procsendmsg = modlibsocket.NewProc("sendmsg") + procAccess = modlibc.NewProc("access") + procAdjtime = modlibc.NewProc("adjtime") + procChdir = modlibc.NewProc("chdir") + procChmod = modlibc.NewProc("chmod") + procChown = modlibc.NewProc("chown") + procChroot = modlibc.NewProc("chroot") + procClose = modlibc.NewProc("close") + procDup = modlibc.NewProc("dup") + procExit = modlibc.NewProc("exit") + procFchdir = modlibc.NewProc("fchdir") + procFchmod = modlibc.NewProc("fchmod") + procFchown = modlibc.NewProc("fchown") + procFpathconf = modlibc.NewProc("fpathconf") + procFstat = modlibc.NewProc("fstat") + procGetdents = modlibc.NewProc("getdents") + procGetgid = modlibc.NewProc("getgid") + procGetpid = modlibc.NewProc("getpid") + procGeteuid = modlibc.NewProc("geteuid") + procGetegid = modlibc.NewProc("getegid") + procGetppid = modlibc.NewProc("getppid") + procGetpriority = modlibc.NewProc("getpriority") + procGetrlimit = modlibc.NewProc("getrlimit") + procGettimeofday = modlibc.NewProc("gettimeofday") + procGetuid = modlibc.NewProc("getuid") + procKill = modlibc.NewProc("kill") + procLchown = modlibc.NewProc("lchown") + procLink = modlibc.NewProc("link") + proclisten = modlibsocket.NewProc("listen") + procLstat = modlibc.NewProc("lstat") + procMkdir = modlibc.NewProc("mkdir") + procMknod = modlibc.NewProc("mknod") + procNanosleep = modlibc.NewProc("nanosleep") + procOpen = modlibc.NewProc("open") + procPathconf = modlibc.NewProc("pathconf") + procPread = modlibc.NewProc("pread") + procPwrite = modlibc.NewProc("pwrite") + procread = modlibc.NewProc("read") + procReadlink = modlibc.NewProc("readlink") + procRename = modlibc.NewProc("rename") + procRmdir = modlibc.NewProc("rmdir") + proclseek = modlibc.NewProc("lseek") + procSetegid = modlibc.NewProc("setegid") + procSeteuid = modlibc.NewProc("seteuid") + procSetgid = modlibc.NewProc("setgid") + procSetpgid = modlibc.NewProc("setpgid") + procSetpriority = modlibc.NewProc("setpriority") + procSetregid = modlibc.NewProc("setregid") + procSetreuid = modlibc.NewProc("setreuid") + procSetrlimit = modlibc.NewProc("setrlimit") + procSetsid = modlibc.NewProc("setsid") + procSetuid = modlibc.NewProc("setuid") + procshutdown = modlibsocket.NewProc("shutdown") + procStat = modlibc.NewProc("stat") + procSymlink = modlibc.NewProc("symlink") + procSync = modlibc.NewProc("sync") + procTruncate = modlibc.NewProc("truncate") + procFsync = modlibc.NewProc("fsync") + procFtruncate = modlibc.NewProc("ftruncate") + procUmask = modlibc.NewProc("umask") + procUnlink = modlibc.NewProc("unlink") + procUtimes = modlibc.NewProc("utimes") + procbind = modlibsocket.NewProc("bind") + procconnect = modlibsocket.NewProc("connect") + procmmap = modlibc.NewProc("mmap") + procmunmap = modlibc.NewProc("munmap") + procsendto = modlibsocket.NewProc("sendto") + procsocket = modlibsocket.NewProc("socket") + procsocketpair = modlibsocket.NewProc("socketpair") + procwrite = modlibc.NewProc("write") + procgetsockopt = modlibsocket.NewProc("getsockopt") + procgetpeername = modlibsocket.NewProc("getpeername") + procgetsockname = modlibsocket.NewProc("getsockname") + procsetsockopt = modlibsocket.NewProc("setsockopt") + procrecvfrom = modlibsocket.NewProc("recvfrom") + procrecvmsg = modlibsocket.NewProc("recvmsg") +) + +func getgroups(ngid int, gid *_Gid_t) (n int, err error) { + r0, _, e1 := rawSysvicall6(procgetgroups.Addr(), 2, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0, 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func setgroups(ngid int, gid *_Gid_t) (err error) { + _, _, e1 := rawSysvicall6(procsetgroups.Addr(), 2, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func fcntl(fd int, cmd int, arg int) (val int, err error) { + r0, _, e1 := sysvicall6(procfcntl.Addr(), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0) + val = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { + r0, _, e1 := sysvicall6(procaccept.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0) + fd = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := sysvicall6(procsendmsg.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Access(path string, mode uint32) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procAccess.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Adjtime(delta *Timeval, olddelta *Timeval) (err error) { + _, _, e1 := sysvicall6(procAdjtime.Addr(), 2, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Chdir(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procChdir.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Chmod(path string, mode uint32) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procChmod.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Chown(path string, uid int, gid int) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procChown.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Chroot(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procChroot.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Close(fd int) (err error) { + _, _, e1 := sysvicall6(procClose.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Dup(fd int) (nfd int, err error) { + r0, _, e1 := sysvicall6(procDup.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0) + nfd = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Exit(code int) { + sysvicall6(procExit.Addr(), 1, uintptr(code), 0, 0, 0, 0, 0) + return +} + +func Fchdir(fd int) (err error) { + _, _, e1 := sysvicall6(procFchdir.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Fchmod(fd int, mode uint32) (err error) { + _, _, e1 := sysvicall6(procFchmod.Addr(), 2, uintptr(fd), uintptr(mode), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Fchown(fd int, uid int, gid int) (err error) { + _, _, e1 := sysvicall6(procFchown.Addr(), 3, uintptr(fd), uintptr(uid), uintptr(gid), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Fpathconf(fd int, name int) (val int, err error) { + r0, _, e1 := sysvicall6(procFpathconf.Addr(), 2, uintptr(fd), uintptr(name), 0, 0, 0, 0) + val = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Fstat(fd int, stat *Stat_t) (err error) { + _, _, e1 := sysvicall6(procFstat.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Getdents(fd int, buf []byte, basep *uintptr) (n int, err error) { + var _p0 *byte + if len(buf) > 0 { + _p0 = &buf[0] + } + r0, _, e1 := sysvicall6(procGetdents.Addr(), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Getgid() (gid int) { + r0, _, _ := rawSysvicall6(procGetgid.Addr(), 0, 0, 0, 0, 0, 0, 0) + gid = int(r0) + return +} + +func Getpid() (pid int) { + r0, _, _ := rawSysvicall6(procGetpid.Addr(), 0, 0, 0, 0, 0, 0, 0) + pid = int(r0) + return +} + +func Geteuid() (euid int) { + r0, _, _ := sysvicall6(procGeteuid.Addr(), 0, 0, 0, 0, 0, 0, 0) + euid = int(r0) + return +} + +func Getegid() (egid int) { + r0, _, _ := sysvicall6(procGetegid.Addr(), 0, 0, 0, 0, 0, 0, 0) + egid = int(r0) + return +} + +func Getppid() (ppid int) { + r0, _, _ := sysvicall6(procGetppid.Addr(), 0, 0, 0, 0, 0, 0, 0) + ppid = int(r0) + return +} + +func Getpriority(which int, who int) (n int, err error) { + r0, _, e1 := sysvicall6(procGetpriority.Addr(), 2, uintptr(which), uintptr(who), 0, 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Getrlimit(which int, lim *Rlimit) (err error) { + _, _, e1 := rawSysvicall6(procGetrlimit.Addr(), 2, uintptr(which), uintptr(unsafe.Pointer(lim)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Gettimeofday(tv *Timeval) (err error) { + _, _, e1 := rawSysvicall6(procGettimeofday.Addr(), 1, uintptr(unsafe.Pointer(tv)), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Getuid() (uid int) { + r0, _, _ := rawSysvicall6(procGetuid.Addr(), 0, 0, 0, 0, 0, 0, 0) + uid = int(r0) + return +} + +func Kill(pid int, signum Signal) (err error) { + _, _, e1 := sysvicall6(procKill.Addr(), 2, uintptr(pid), uintptr(signum), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Lchown(path string, uid int, gid int) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procLchown.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Link(path string, link string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + var _p1 *byte + _p1, err = BytePtrFromString(link) + if err != nil { + return + } + _, _, e1 := sysvicall6(procLink.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Listen(s int, backlog int) (err error) { + _, _, e1 := sysvicall6(proclisten.Addr(), 2, uintptr(s), uintptr(backlog), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Lstat(path string, stat *Stat_t) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procLstat.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Mkdir(path string, mode uint32) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procMkdir.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Mknod(path string, mode uint32, dev int) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procMknod.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Nanosleep(time *Timespec, leftover *Timespec) (err error) { + _, _, e1 := sysvicall6(procNanosleep.Addr(), 2, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Open(path string, mode int, perm uint32) (fd int, err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + r0, _, e1 := sysvicall6(procOpen.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0, 0) + fd = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Pathconf(path string, name int) (val int, err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + r0, _, e1 := sysvicall6(procPathconf.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0, 0, 0, 0) + val = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Pread(fd int, p []byte, offset int64) (n int, err error) { + var _p0 *byte + if len(p) > 0 { + _p0 = &p[0] + } + r0, _, e1 := sysvicall6(procPread.Addr(), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Pwrite(fd int, p []byte, offset int64) (n int, err error) { + var _p0 *byte + if len(p) > 0 { + _p0 = &p[0] + } + r0, _, e1 := sysvicall6(procPwrite.Addr(), 4, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(offset), 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func read(fd int, p []byte) (n int, err error) { + var _p0 *byte + if len(p) > 0 { + _p0 = &p[0] + } + r0, _, e1 := sysvicall6(procread.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Readlink(path string, buf []byte) (n int, err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + var _p1 *byte + if len(buf) > 0 { + _p1 = &buf[0] + } + r0, _, e1 := sysvicall6(procReadlink.Addr(), 3, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(len(buf)), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Rename(from string, to string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(from) + if err != nil { + return + } + var _p1 *byte + _p1, err = BytePtrFromString(to) + if err != nil { + return + } + _, _, e1 := sysvicall6(procRename.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Rmdir(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procRmdir.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { + r0, _, e1 := sysvicall6(proclseek.Addr(), 3, uintptr(fd), uintptr(offset), uintptr(whence), 0, 0, 0) + newoffset = int64(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Setegid(egid int) (err error) { + _, _, e1 := rawSysvicall6(procSetegid.Addr(), 1, uintptr(egid), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Seteuid(euid int) (err error) { + _, _, e1 := rawSysvicall6(procSeteuid.Addr(), 1, uintptr(euid), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setgid(gid int) (err error) { + _, _, e1 := rawSysvicall6(procSetgid.Addr(), 1, uintptr(gid), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setpgid(pid int, pgid int) (err error) { + _, _, e1 := rawSysvicall6(procSetpgid.Addr(), 2, uintptr(pid), uintptr(pgid), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setpriority(which int, who int, prio int) (err error) { + _, _, e1 := sysvicall6(procSetpriority.Addr(), 3, uintptr(which), uintptr(who), uintptr(prio), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setregid(rgid int, egid int) (err error) { + _, _, e1 := rawSysvicall6(procSetregid.Addr(), 2, uintptr(rgid), uintptr(egid), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setreuid(ruid int, euid int) (err error) { + _, _, e1 := rawSysvicall6(procSetreuid.Addr(), 2, uintptr(ruid), uintptr(euid), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setrlimit(which int, lim *Rlimit) (err error) { + _, _, e1 := rawSysvicall6(procSetrlimit.Addr(), 2, uintptr(which), uintptr(unsafe.Pointer(lim)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Setsid() (pid int, err error) { + r0, _, e1 := rawSysvicall6(procSetsid.Addr(), 0, 0, 0, 0, 0, 0, 0) + pid = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func Setuid(uid int) (err error) { + _, _, e1 := rawSysvicall6(procSetuid.Addr(), 1, uintptr(uid), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Shutdown(s int, how int) (err error) { + _, _, e1 := sysvicall6(procshutdown.Addr(), 2, uintptr(s), uintptr(how), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Stat(path string, stat *Stat_t) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procStat.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Symlink(path string, link string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + var _p1 *byte + _p1, err = BytePtrFromString(link) + if err != nil { + return + } + _, _, e1 := sysvicall6(procSymlink.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Sync() (err error) { + _, _, e1 := sysvicall6(procSync.Addr(), 0, 0, 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Truncate(path string, length int64) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procTruncate.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Fsync(fd int) (err error) { + _, _, e1 := sysvicall6(procFsync.Addr(), 1, uintptr(fd), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Ftruncate(fd int, length int64) (err error) { + _, _, e1 := sysvicall6(procFtruncate.Addr(), 2, uintptr(fd), uintptr(length), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Umask(newmask int) (oldmask int) { + r0, _, _ := sysvicall6(procUmask.Addr(), 1, uintptr(newmask), 0, 0, 0, 0, 0) + oldmask = int(r0) + return +} + +func Unlink(path string) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procUnlink.Addr(), 1, uintptr(unsafe.Pointer(_p0)), 0, 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func Utimes(path string, times *[2]Timeval) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) + if err != nil { + return + } + _, _, e1 := sysvicall6(procUtimes.Addr(), 2, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { + _, _, e1 := sysvicall6(procbind.Addr(), 3, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { + _, _, e1 := sysvicall6(procconnect.Addr(), 3, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { + r0, _, e1 := sysvicall6(procmmap.Addr(), 6, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos)) + ret = uintptr(r0) + if e1 != 0 { + err = e1 + } + return +} + +func munmap(addr uintptr, length uintptr) (err error) { + _, _, e1 := sysvicall6(procmunmap.Addr(), 2, uintptr(addr), uintptr(length), 0, 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { + var _p0 *byte + if len(buf) > 0 { + _p0 = &buf[0] + } + _, _, e1 := sysvicall6(procsendto.Addr(), 6, uintptr(s), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) + if e1 != 0 { + err = e1 + } + return +} + +func socket(domain int, typ int, proto int) (fd int, err error) { + r0, _, e1 := sysvicall6(procsocket.Addr(), 3, uintptr(domain), uintptr(typ), uintptr(proto), 0, 0, 0) + fd = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { + _, _, e1 := rawSysvicall6(procsocketpair.Addr(), 4, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func write(fd int, p []byte) (n int, err error) { + var _p0 *byte + if len(p) > 0 { + _p0 = &p[0] + } + r0, _, e1 := sysvicall6(procwrite.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { + _, _, e1 := sysvicall6(procgetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) + if e1 != 0 { + err = e1 + } + return +} + +func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { + _, _, e1 := rawSysvicall6(procgetpeername.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { + _, _, e1 := sysvicall6(procgetsockname.Addr(), 3, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), 0, 0, 0) + if e1 != 0 { + err = e1 + } + return +} + +func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { + _, _, e1 := sysvicall6(procsetsockopt.Addr(), 5, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) + if e1 != 0 { + err = e1 + } + return +} + +func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) { + var _p0 *byte + if len(p) > 0 { + _p0 = &p[0] + } + r0, _, e1 := sysvicall6(procrecvfrom.Addr(), 6, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} + +func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { + r0, _, e1 := sysvicall6(procrecvmsg.Addr(), 3, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags), 0, 0, 0) + n = int(r0) + if e1 != 0 { + err = e1 + } + return +} diff --git a/src/pkg/syscall/zsyscall_windows_386.go b/src/pkg/syscall/zsyscall_windows_386.go index 3cd12dd47..132adafef 100644 --- a/src/pkg/syscall/zsyscall_windows_386.go +++ b/src/pkg/syscall/zsyscall_windows_386.go @@ -1,4 +1,4 @@ -// mksyscall_windows.pl -l32 syscall_windows.go security_windows.go syscall_windows_386.go +// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go syscall_windows_386.go // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT package syscall @@ -1323,7 +1323,7 @@ func Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int3 return } -func bind(s Handle, name uintptr, namelen int32) (err error) { +func bind(s Handle, name unsafe.Pointer, namelen int32) (err error) { r1, _, e1 := Syscall(procbind.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen)) if r1 == socket_error { if e1 != 0 { @@ -1335,7 +1335,7 @@ func bind(s Handle, name uintptr, namelen int32) (err error) { return } -func connect(s Handle, name uintptr, namelen int32) (err error) { +func connect(s Handle, name unsafe.Pointer, namelen int32) (err error) { r1, _, e1 := Syscall(procconnect.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen)) if r1 == socket_error { if e1 != 0 { diff --git a/src/pkg/syscall/zsyscall_windows_amd64.go b/src/pkg/syscall/zsyscall_windows_amd64.go index d23c2311a..353a6fd98 100644 --- a/src/pkg/syscall/zsyscall_windows_amd64.go +++ b/src/pkg/syscall/zsyscall_windows_amd64.go @@ -1,4 +1,4 @@ -// mksyscall_windows.pl syscall_windows.go security_windows.go syscall_windows_amd64.go +// go build mksyscall_windows.go && ./mksyscall_windows syscall_windows.go security_windows.go syscall_windows_amd64.go // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT package syscall @@ -1323,7 +1323,7 @@ func Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int3 return } -func bind(s Handle, name uintptr, namelen int32) (err error) { +func bind(s Handle, name unsafe.Pointer, namelen int32) (err error) { r1, _, e1 := Syscall(procbind.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen)) if r1 == socket_error { if e1 != 0 { @@ -1335,7 +1335,7 @@ func bind(s Handle, name uintptr, namelen int32) (err error) { return } -func connect(s Handle, name uintptr, namelen int32) (err error) { +func connect(s Handle, name unsafe.Pointer, namelen int32) (err error) { r1, _, e1 := Syscall(procconnect.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen)) if r1 == socket_error { if e1 != 0 { diff --git a/src/pkg/syscall/zsysctl_openbsd.go b/src/pkg/syscall/zsysctl_openbsd.go index a5914f3f0..923b2c29f 100644 --- a/src/pkg/syscall/zsysctl_openbsd.go +++ b/src/pkg/syscall/zsysctl_openbsd.go @@ -48,8 +48,7 @@ var sysctlMib = []mibentry{ {"kern.cp_time2", []_C_int{1, 71}}, {"kern.cryptodevallowsoft", []_C_int{1, 53}}, {"kern.domainname", []_C_int{1, 22}}, - {"kern.file", []_C_int{1, 15}}, - {"kern.file2", []_C_int{1, 73}}, + {"kern.file", []_C_int{1, 73}}, {"kern.forkstat", []_C_int{1, 42}}, {"kern.fscale", []_C_int{1, 46}}, {"kern.fsync", []_C_int{1, 33}}, @@ -87,7 +86,6 @@ var sysctlMib = []mibentry{ {"kern.proc", []_C_int{1, 66}}, {"kern.random", []_C_int{1, 31}}, {"kern.rawpartition", []_C_int{1, 24}}, - {"kern.rthreads", []_C_int{1, 74}}, {"kern.saved_ids", []_C_int{1, 20}}, {"kern.securelevel", []_C_int{1, 9}}, {"kern.seminfo", []_C_int{1, 61}}, @@ -226,8 +224,6 @@ var sysctlMib = []mibentry{ {"net.inet6.ip6.forwsrcrt", []_C_int{4, 24, 17, 5}}, {"net.inet6.ip6.hdrnestlimit", []_C_int{4, 24, 17, 15}}, {"net.inet6.ip6.hlim", []_C_int{4, 24, 17, 3}}, - {"net.inet6.ip6.kame_version", []_C_int{4, 24, 17, 20}}, - {"net.inet6.ip6.keepfaith", []_C_int{4, 24, 17, 13}}, {"net.inet6.ip6.log_interval", []_C_int{4, 24, 17, 14}}, {"net.inet6.ip6.maxdynroutes", []_C_int{4, 24, 17, 48}}, {"net.inet6.ip6.maxfragpackets", []_C_int{4, 24, 17, 9}}, @@ -236,7 +232,7 @@ var sysctlMib = []mibentry{ {"net.inet6.ip6.maxifprefixes", []_C_int{4, 24, 17, 46}}, {"net.inet6.ip6.mforwarding", []_C_int{4, 24, 17, 42}}, {"net.inet6.ip6.mrtproto", []_C_int{4, 24, 17, 8}}, - {"net.inet6.ip6.mtu", []_C_int{4, 24, 17, 4}}, + {"net.inet6.ip6.mtudisctimeout", []_C_int{4, 24, 17, 50}}, {"net.inet6.ip6.multicast_mtudisc", []_C_int{4, 24, 17, 44}}, {"net.inet6.ip6.multipath", []_C_int{4, 24, 17, 43}}, {"net.inet6.ip6.neighborgcthresh", []_C_int{4, 24, 17, 45}}, @@ -258,26 +254,6 @@ var sysctlMib = []mibentry{ {"net.mpls.ttl", []_C_int{4, 33, 2}}, {"net.pflow.stats", []_C_int{4, 34, 1}}, {"net.pipex.enable", []_C_int{4, 35, 1}}, - {"user.bc_base_max", []_C_int{8, 2}}, - {"user.bc_dim_max", []_C_int{8, 3}}, - {"user.bc_scale_max", []_C_int{8, 4}}, - {"user.bc_string_max", []_C_int{8, 5}}, - {"user.coll_weights_max", []_C_int{8, 6}}, - {"user.cs_path", []_C_int{8, 1}}, - {"user.expr_nest_max", []_C_int{8, 7}}, - {"user.line_max", []_C_int{8, 8}}, - {"user.posix2_c_bind", []_C_int{8, 11}}, - {"user.posix2_c_dev", []_C_int{8, 12}}, - {"user.posix2_char_term", []_C_int{8, 13}}, - {"user.posix2_fort_dev", []_C_int{8, 14}}, - {"user.posix2_fort_run", []_C_int{8, 15}}, - {"user.posix2_localedef", []_C_int{8, 16}}, - {"user.posix2_sw_dev", []_C_int{8, 17}}, - {"user.posix2_upe", []_C_int{8, 18}}, - {"user.posix2_version", []_C_int{8, 10}}, - {"user.re_dup_max", []_C_int{8, 9}}, - {"user.stream_max", []_C_int{8, 19}}, - {"user.tzname_max", []_C_int{8, 20}}, {"vm.anonmin", []_C_int{2, 7}}, {"vm.loadavg", []_C_int{2, 2}}, {"vm.maxslp", []_C_int{2, 10}}, diff --git a/src/pkg/syscall/zsysnum_dragonfly_386.go b/src/pkg/syscall/zsysnum_dragonfly_386.go index 68eeb32ac..4b086b921 100644 --- a/src/pkg/syscall/zsysnum_dragonfly_386.go +++ b/src/pkg/syscall/zsysnum_dragonfly_386.go @@ -115,9 +115,6 @@ const ( SYS_UNAME = 164 // { int uname(struct utsname *name); } SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); } SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, \ - SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, int a4, \ - SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, int a4, \ - SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, int a4); } SYS_EXTPREAD = 173 // { ssize_t extpread(int fd, void *buf, \ SYS_EXTPWRITE = 174 // { ssize_t extpwrite(int fd, const void *buf, \ SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); } @@ -300,4 +297,6 @@ const ( SYS_LINKAT = 531 // { int linkat(int fd1, char *path1, int fd2, \ SYS_EACCESS = 532 // { int eaccess(char *path, int flags); } SYS_LPATHCONF = 533 // { int lpathconf(char *path, int name); } + SYS_VMM_GUEST_CTL = 534 // { int vmm_guest_ctl(int op, struct vmm_guest_options *options); } + SYS_VMM_GUEST_SYNC_ADDR = 535 // { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); } ) diff --git a/src/pkg/syscall/zsysnum_dragonfly_amd64.go b/src/pkg/syscall/zsysnum_dragonfly_amd64.go index 68eeb32ac..4b086b921 100644 --- a/src/pkg/syscall/zsysnum_dragonfly_amd64.go +++ b/src/pkg/syscall/zsysnum_dragonfly_amd64.go @@ -115,9 +115,6 @@ const ( SYS_UNAME = 164 // { int uname(struct utsname *name); } SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); } SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, \ - SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, int a4, \ - SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, int a4, \ - SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, int a4); } SYS_EXTPREAD = 173 // { ssize_t extpread(int fd, void *buf, \ SYS_EXTPWRITE = 174 // { ssize_t extpwrite(int fd, const void *buf, \ SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); } @@ -300,4 +297,6 @@ const ( SYS_LINKAT = 531 // { int linkat(int fd1, char *path1, int fd2, \ SYS_EACCESS = 532 // { int eaccess(char *path, int flags); } SYS_LPATHCONF = 533 // { int lpathconf(char *path, int name); } + SYS_VMM_GUEST_CTL = 534 // { int vmm_guest_ctl(int op, struct vmm_guest_options *options); } + SYS_VMM_GUEST_SYNC_ADDR = 535 // { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); } ) diff --git a/src/pkg/syscall/zsysnum_freebsd_386.go b/src/pkg/syscall/zsysnum_freebsd_386.go index 74400b6f6..dfca558bb 100644 --- a/src/pkg/syscall/zsysnum_freebsd_386.go +++ b/src/pkg/syscall/zsysnum_freebsd_386.go @@ -34,8 +34,8 @@ const ( SYS_GETPEERNAME = 31 // { int getpeername(int fdes, \ SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, \ SYS_ACCESS = 33 // { int access(char *path, int amode); } - SYS_CHFLAGS = 34 // { int chflags(char *path, int flags); } - SYS_FCHFLAGS = 35 // { int fchflags(int fd, int flags); } + SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); } + SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); } SYS_SYNC = 36 // { int sync(void); } SYS_KILL = 37 // { int kill(int pid, int signum); } SYS_GETPPID = 39 // { pid_t getppid(void); } @@ -208,14 +208,14 @@ const ( SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \ SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, \ SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \ - SYS_EXTATTR_SET_FILE = 356 // { int extattr_set_file( \ + SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( \ SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( \ SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \ SYS_GETRESUID = 360 // { int getresuid(uid_t *ruid, uid_t *euid, \ SYS_GETRESGID = 361 // { int getresgid(gid_t *rgid, gid_t *egid, \ SYS_KQUEUE = 362 // { int kqueue(void); } SYS_KEVENT = 363 // { int kevent(int fd, \ - SYS_EXTATTR_SET_FD = 371 // { int extattr_set_fd(int fd, \ + SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, \ SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, \ SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, \ SYS___SETUGID = 374 // { int __setugid(int flag); } @@ -228,7 +228,7 @@ const ( SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, \ SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, \ SYS_KENV = 390 // { int kenv(int what, const char *name, \ - SYS_LCHFLAGS = 391 // { int lchflags(const char *path, int flags); } + SYS_LCHFLAGS = 391 // { int lchflags(const char *path, \ SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, \ SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, \ SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, \ @@ -239,7 +239,7 @@ const ( SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, \ SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, \ SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, \ - SYS_EXTATTR_SET_LINK = 412 // { int extattr_set_link( \ + SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( \ SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( \ SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( \ SYS___MAC_EXECVE = 415 // { int __mac_execve(char *fname, char **argv, \ @@ -338,5 +338,11 @@ const ( SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, \ SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, \ SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, \ - SYS_WAIT6 = 532 // { int wait6(int idtype, int id, \ + SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, \ + SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, \ + SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, \ + SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, \ + SYS_ACCEPT4 = 541 // { int accept4(int s, \ + SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); } + SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, \ ) diff --git a/src/pkg/syscall/zsysnum_freebsd_amd64.go b/src/pkg/syscall/zsysnum_freebsd_amd64.go index 74400b6f6..dfca558bb 100644 --- a/src/pkg/syscall/zsysnum_freebsd_amd64.go +++ b/src/pkg/syscall/zsysnum_freebsd_amd64.go @@ -34,8 +34,8 @@ const ( SYS_GETPEERNAME = 31 // { int getpeername(int fdes, \ SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, \ SYS_ACCESS = 33 // { int access(char *path, int amode); } - SYS_CHFLAGS = 34 // { int chflags(char *path, int flags); } - SYS_FCHFLAGS = 35 // { int fchflags(int fd, int flags); } + SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); } + SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); } SYS_SYNC = 36 // { int sync(void); } SYS_KILL = 37 // { int kill(int pid, int signum); } SYS_GETPPID = 39 // { pid_t getppid(void); } @@ -208,14 +208,14 @@ const ( SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \ SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, \ SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \ - SYS_EXTATTR_SET_FILE = 356 // { int extattr_set_file( \ + SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( \ SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( \ SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \ SYS_GETRESUID = 360 // { int getresuid(uid_t *ruid, uid_t *euid, \ SYS_GETRESGID = 361 // { int getresgid(gid_t *rgid, gid_t *egid, \ SYS_KQUEUE = 362 // { int kqueue(void); } SYS_KEVENT = 363 // { int kevent(int fd, \ - SYS_EXTATTR_SET_FD = 371 // { int extattr_set_fd(int fd, \ + SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, \ SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, \ SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, \ SYS___SETUGID = 374 // { int __setugid(int flag); } @@ -228,7 +228,7 @@ const ( SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, \ SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, \ SYS_KENV = 390 // { int kenv(int what, const char *name, \ - SYS_LCHFLAGS = 391 // { int lchflags(const char *path, int flags); } + SYS_LCHFLAGS = 391 // { int lchflags(const char *path, \ SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, \ SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, \ SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, \ @@ -239,7 +239,7 @@ const ( SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, \ SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, \ SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, \ - SYS_EXTATTR_SET_LINK = 412 // { int extattr_set_link( \ + SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( \ SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( \ SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( \ SYS___MAC_EXECVE = 415 // { int __mac_execve(char *fname, char **argv, \ @@ -338,5 +338,11 @@ const ( SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, \ SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, \ SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, \ - SYS_WAIT6 = 532 // { int wait6(int idtype, int id, \ + SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, \ + SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, \ + SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, \ + SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, \ + SYS_ACCEPT4 = 541 // { int accept4(int s, \ + SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); } + SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, \ ) diff --git a/src/pkg/syscall/zsysnum_freebsd_arm.go b/src/pkg/syscall/zsysnum_freebsd_arm.go index 61a6a3295..dfca558bb 100644 --- a/src/pkg/syscall/zsysnum_freebsd_arm.go +++ b/src/pkg/syscall/zsysnum_freebsd_arm.go @@ -34,8 +34,8 @@ const ( SYS_GETPEERNAME = 31 // { int getpeername(int fdes, \ SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, \ SYS_ACCESS = 33 // { int access(char *path, int amode); } - SYS_CHFLAGS = 34 // { int chflags(char *path, int flags); } - SYS_FCHFLAGS = 35 // { int fchflags(int fd, int flags); } + SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); } + SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); } SYS_SYNC = 36 // { int sync(void); } SYS_KILL = 37 // { int kill(int pid, int signum); } SYS_GETPPID = 39 // { pid_t getppid(void); } @@ -208,14 +208,14 @@ const ( SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \ SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, \ SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \ - SYS_EXTATTR_SET_FILE = 356 // { int extattr_set_file( \ + SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( \ SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( \ SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \ SYS_GETRESUID = 360 // { int getresuid(uid_t *ruid, uid_t *euid, \ SYS_GETRESGID = 361 // { int getresgid(gid_t *rgid, gid_t *egid, \ SYS_KQUEUE = 362 // { int kqueue(void); } SYS_KEVENT = 363 // { int kevent(int fd, \ - SYS_EXTATTR_SET_FD = 371 // { int extattr_set_fd(int fd, \ + SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, \ SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, \ SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, \ SYS___SETUGID = 374 // { int __setugid(int flag); } @@ -228,7 +228,7 @@ const ( SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, \ SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, \ SYS_KENV = 390 // { int kenv(int what, const char *name, \ - SYS_LCHFLAGS = 391 // { int lchflags(const char *path, int flags); } + SYS_LCHFLAGS = 391 // { int lchflags(const char *path, \ SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, \ SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, \ SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, \ @@ -239,7 +239,7 @@ const ( SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, \ SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, \ SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, \ - SYS_EXTATTR_SET_LINK = 412 // { int extattr_set_link( \ + SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( \ SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( \ SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( \ SYS___MAC_EXECVE = 415 // { int __mac_execve(char *fname, char **argv, \ @@ -322,7 +322,7 @@ const ( SYS_CLOSEFROM = 509 // { int closefrom(int lowfd); } SYS_LPATHCONF = 513 // { int lpathconf(char *path, int name); } SYS_CAP_NEW = 514 // { int cap_new(int fd, uint64_t rights); } - SYS_CAP_RIGHTS_GET = 515 // { int cap_rights_get(int fd, \ + SYS_CAP_GETRIGHTS = 515 // { int cap_getrights(int fd, \ SYS_CAP_ENTER = 516 // { int cap_enter(void); } SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); } SYS_PDFORK = 518 // { int pdfork(int *fdp, int flags); } @@ -338,10 +338,11 @@ const ( SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, \ SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, \ SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, \ - SYS_WAIT6 = 532 // { int wait6(int idtype, int id, \ - SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, \ - SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, \ - SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, \ - SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, \ - SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, \ + SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, \ + SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, \ + SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, \ + SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, \ + SYS_ACCEPT4 = 541 // { int accept4(int s, \ + SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); } + SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, \ ) diff --git a/src/pkg/syscall/zsysnum_openbsd_386.go b/src/pkg/syscall/zsysnum_openbsd_386.go index 82c98b90e..3b9ac4c94 100644 --- a/src/pkg/syscall/zsysnum_openbsd_386.go +++ b/src/pkg/syscall/zsysnum_openbsd_386.go @@ -10,10 +10,10 @@ const ( SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, \ SYS_OPEN = 5 // { int sys_open(const char *path, \ SYS_CLOSE = 6 // { int sys_close(int fd); } - SYS_WAIT4 = 7 // { pid_t sys_wait4(pid_t pid, int *status, int options, \ SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, \ SYS_LINK = 9 // { int sys_link(const char *path, const char *link); } SYS_UNLINK = 10 // { int sys_unlink(const char *path); } + SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, \ SYS_CHDIR = 12 // { int sys_chdir(const char *path); } SYS_FCHDIR = 13 // { int sys_fchdir(int fd); } SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, \ @@ -21,6 +21,7 @@ const ( SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, \ SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); } + SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, \ SYS_GETPID = 20 // { pid_t sys_getpid(void); } SYS_MOUNT = 21 // { int sys_mount(const char *type, const char *path, \ SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); } @@ -39,8 +40,11 @@ const ( SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); } SYS_SYNC = 36 // { void sys_sync(void); } SYS_KILL = 37 // { int sys_kill(int pid, int signum); } + SYS_STAT = 38 // { int sys_stat(const char *path, struct stat *ub); } SYS_GETPPID = 39 // { pid_t sys_getppid(void); } + SYS_LSTAT = 40 // { int sys_lstat(const char *path, struct stat *ub); } SYS_DUP = 41 // { int sys_dup(int fd); } + SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, \ SYS_GETEGID = 43 // { gid_t sys_getegid(void); } SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, \ SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, \ @@ -51,6 +55,7 @@ const ( SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); } SYS_ACCT = 51 // { int sys_acct(const char *path); } SYS_SIGPENDING = 52 // { int sys_sigpending(void); } + SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); } SYS_IOCTL = 54 // { int sys_ioctl(int fd, \ SYS_REBOOT = 55 // { int sys_reboot(int opt); } SYS_REVOKE = 56 // { int sys_revoke(const char *path); } @@ -59,36 +64,52 @@ const ( SYS_EXECVE = 59 // { int sys_execve(const char *path, \ SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); } SYS_CHROOT = 61 // { int sys_chroot(const char *path); } + SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \ + SYS_STATFS = 63 // { int sys_statfs(const char *path, \ + SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); } + SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, \ SYS_VFORK = 66 // { int sys_vfork(void); } + SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, \ + SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, \ + SYS_SETITIMER = 69 // { int sys_setitimer(int which, \ + SYS_GETITIMER = 70 // { int sys_getitimer(int which, \ + SYS_SELECT = 71 // { int sys_select(int nd, fd_set *in, fd_set *ou, \ + SYS_KEVENT = 72 // { int sys_kevent(int fd, \ SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); } SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, \ SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, \ + SYS_UTIMES = 76 // { int sys_utimes(const char *path, \ + SYS_FUTIMES = 77 // { int sys_futimes(int fd, \ SYS_MINCORE = 78 // { int sys_mincore(void *addr, size_t len, \ SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, \ SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, \ SYS_GETPGRP = 81 // { int sys_getpgrp(void); } SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, int pgid); } - SYS_SETITIMER = 83 // { int sys_setitimer(int which, \ - SYS_GETITIMER = 86 // { int sys_getitimer(int which, \ + SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, \ + SYS_FUTIMENS = 85 // { int sys_futimens(int fd, \ + SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, \ + SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, \ + SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, \ SYS_DUP2 = 90 // { int sys_dup2(int from, int to); } + SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, \ SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); } - SYS_SELECT = 93 // { int sys_select(int nd, fd_set *in, fd_set *ou, \ + SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, \ SYS_FSYNC = 95 // { int sys_fsync(int fd); } SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); } SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); } SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, \ + SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); } SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); } SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); } SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, \ SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, \ SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); } + SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, \ + SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set *in, fd_set *ou, \ SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); } - SYS_GETTIMEOFDAY = 116 // { int sys_gettimeofday(struct timeval *tp, \ - SYS_GETRUSAGE = 117 // { int sys_getrusage(int who, struct rusage *rusage); } SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, \ SYS_READV = 120 // { ssize_t sys_readv(int fd, \ SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, \ - SYS_SETTIMEOFDAY = 122 // { int sys_settimeofday(const struct timeval *tv, \ SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); } SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); } SYS_SETREUID = 126 // { int sys_setreuid(uid_t ruid, uid_t euid); } @@ -101,7 +122,6 @@ const ( SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, \ SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); } SYS_RMDIR = 137 // { int sys_rmdir(const char *path); } - SYS_UTIMES = 138 // { int sys_utimes(const char *path, \ SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, \ SYS_SETSID = 147 // { int sys_setsid(void); } SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, \ @@ -122,21 +142,17 @@ const ( SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, \ SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, \ SYS_FTRUNCATE = 201 // { int sys_ftruncate(int fd, int pad, off_t length); } - SYS___SYSCTL = 202 // { int sys___sysctl(int *name, u_int namelen, \ + SYS___SYSCTL = 202 // { int sys___sysctl(const int *name, u_int namelen, \ SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); } SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); } - SYS_FUTIMES = 206 // { int sys_futimes(int fd, \ SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); } + SYS_UTRACE = 209 // { int sys_utrace(const char *label, const void *addr, \ SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); } SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); } SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \ SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \ SYS_SHMAT = 228 // { void *sys_shmat(int shmid, const void *shmaddr, \ SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); } - SYS_CLOCK_GETTIME = 232 // { int sys_clock_gettime(clockid_t clock_id, \ - SYS_CLOCK_SETTIME = 233 // { int sys_clock_settime(clockid_t clock_id, \ - SYS_CLOCK_GETRES = 234 // { int sys_clock_getres(clockid_t clock_id, \ - SYS_NANOSLEEP = 240 // { int sys_nanosleep(const struct timespec *rqtp, \ SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, \ SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, \ SYS_ISSETUGID = 253 // { int sys_issetugid(void); } @@ -148,7 +164,6 @@ const ( SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, \ SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, \ SYS_KQUEUE = 269 // { int sys_kqueue(void); } - SYS_KEVENT = 270 // { int sys_kevent(int fd, \ SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); } SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); } SYS_GETRESUID = 281 // { int sys_getresuid(uid_t *ruid, uid_t *euid, \ @@ -160,32 +175,22 @@ const ( SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, \ SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); } SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, \ - SYS_STAT = 291 // { int sys_stat(const char *path, struct stat *ub); } - SYS_FSTAT = 292 // { int sys_fstat(int fd, struct stat *sb); } - SYS_LSTAT = 293 // { int sys_lstat(const char *path, struct stat *ub); } SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, \ SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, \ SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, \ SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, \ SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); } SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); } - SYS___THRSLEEP = 300 // { int sys___thrsleep(const volatile void *ident, \ SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, \ SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); } SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, \ SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); } SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, \ - SYS_GETFSSTAT = 306 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \ - SYS_STATFS = 307 // { int sys_statfs(const char *path, \ - SYS_FSTATFS = 308 // { int sys_fstatfs(int fd, struct statfs *buf); } - SYS_FHSTATFS = 309 // { int sys_fhstatfs(const fhandle_t *fhp, \ SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); } SYS_GETRTABLE = 311 // { int sys_getrtable(void); } - SYS_GETDIRENTRIES = 312 // { int sys_getdirentries(int fd, char *buf, \ SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, \ SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, \ SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, \ - SYS_FSTATAT = 316 // { int sys_fstatat(int fd, const char *path, \ SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, \ SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, \ SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, \ @@ -195,8 +200,6 @@ const ( SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, \ SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, \ SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, \ - SYS_UTIMENSAT = 326 // { int sys_utimensat(int fd, const char *path, \ - SYS_FUTIMENS = 327 // { int sys_futimens(int fd, \ SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); } SYS___GET_TCB = 330 // { void *sys___get_tcb(void); } ) diff --git a/src/pkg/syscall/zsysnum_openbsd_amd64.go b/src/pkg/syscall/zsysnum_openbsd_amd64.go index 82c98b90e..3b9ac4c94 100644 --- a/src/pkg/syscall/zsysnum_openbsd_amd64.go +++ b/src/pkg/syscall/zsysnum_openbsd_amd64.go @@ -10,10 +10,10 @@ const ( SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, \ SYS_OPEN = 5 // { int sys_open(const char *path, \ SYS_CLOSE = 6 // { int sys_close(int fd); } - SYS_WAIT4 = 7 // { pid_t sys_wait4(pid_t pid, int *status, int options, \ SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, \ SYS_LINK = 9 // { int sys_link(const char *path, const char *link); } SYS_UNLINK = 10 // { int sys_unlink(const char *path); } + SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, \ SYS_CHDIR = 12 // { int sys_chdir(const char *path); } SYS_FCHDIR = 13 // { int sys_fchdir(int fd); } SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, \ @@ -21,6 +21,7 @@ const ( SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, \ SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); } + SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, \ SYS_GETPID = 20 // { pid_t sys_getpid(void); } SYS_MOUNT = 21 // { int sys_mount(const char *type, const char *path, \ SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); } @@ -39,8 +40,11 @@ const ( SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); } SYS_SYNC = 36 // { void sys_sync(void); } SYS_KILL = 37 // { int sys_kill(int pid, int signum); } + SYS_STAT = 38 // { int sys_stat(const char *path, struct stat *ub); } SYS_GETPPID = 39 // { pid_t sys_getppid(void); } + SYS_LSTAT = 40 // { int sys_lstat(const char *path, struct stat *ub); } SYS_DUP = 41 // { int sys_dup(int fd); } + SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, \ SYS_GETEGID = 43 // { gid_t sys_getegid(void); } SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, \ SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, \ @@ -51,6 +55,7 @@ const ( SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); } SYS_ACCT = 51 // { int sys_acct(const char *path); } SYS_SIGPENDING = 52 // { int sys_sigpending(void); } + SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); } SYS_IOCTL = 54 // { int sys_ioctl(int fd, \ SYS_REBOOT = 55 // { int sys_reboot(int opt); } SYS_REVOKE = 56 // { int sys_revoke(const char *path); } @@ -59,36 +64,52 @@ const ( SYS_EXECVE = 59 // { int sys_execve(const char *path, \ SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); } SYS_CHROOT = 61 // { int sys_chroot(const char *path); } + SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \ + SYS_STATFS = 63 // { int sys_statfs(const char *path, \ + SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); } + SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, \ SYS_VFORK = 66 // { int sys_vfork(void); } + SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, \ + SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, \ + SYS_SETITIMER = 69 // { int sys_setitimer(int which, \ + SYS_GETITIMER = 70 // { int sys_getitimer(int which, \ + SYS_SELECT = 71 // { int sys_select(int nd, fd_set *in, fd_set *ou, \ + SYS_KEVENT = 72 // { int sys_kevent(int fd, \ SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); } SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, \ SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, \ + SYS_UTIMES = 76 // { int sys_utimes(const char *path, \ + SYS_FUTIMES = 77 // { int sys_futimes(int fd, \ SYS_MINCORE = 78 // { int sys_mincore(void *addr, size_t len, \ SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, \ SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, \ SYS_GETPGRP = 81 // { int sys_getpgrp(void); } SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, int pgid); } - SYS_SETITIMER = 83 // { int sys_setitimer(int which, \ - SYS_GETITIMER = 86 // { int sys_getitimer(int which, \ + SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, \ + SYS_FUTIMENS = 85 // { int sys_futimens(int fd, \ + SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, \ + SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, \ + SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, \ SYS_DUP2 = 90 // { int sys_dup2(int from, int to); } + SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, \ SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); } - SYS_SELECT = 93 // { int sys_select(int nd, fd_set *in, fd_set *ou, \ + SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, \ SYS_FSYNC = 95 // { int sys_fsync(int fd); } SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); } SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); } SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, \ + SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); } SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); } SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); } SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, \ SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, \ SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); } + SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, \ + SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set *in, fd_set *ou, \ SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); } - SYS_GETTIMEOFDAY = 116 // { int sys_gettimeofday(struct timeval *tp, \ - SYS_GETRUSAGE = 117 // { int sys_getrusage(int who, struct rusage *rusage); } SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, \ SYS_READV = 120 // { ssize_t sys_readv(int fd, \ SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, \ - SYS_SETTIMEOFDAY = 122 // { int sys_settimeofday(const struct timeval *tv, \ SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); } SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); } SYS_SETREUID = 126 // { int sys_setreuid(uid_t ruid, uid_t euid); } @@ -101,7 +122,6 @@ const ( SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, \ SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); } SYS_RMDIR = 137 // { int sys_rmdir(const char *path); } - SYS_UTIMES = 138 // { int sys_utimes(const char *path, \ SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, \ SYS_SETSID = 147 // { int sys_setsid(void); } SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, \ @@ -122,21 +142,17 @@ const ( SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, \ SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, \ SYS_FTRUNCATE = 201 // { int sys_ftruncate(int fd, int pad, off_t length); } - SYS___SYSCTL = 202 // { int sys___sysctl(int *name, u_int namelen, \ + SYS___SYSCTL = 202 // { int sys___sysctl(const int *name, u_int namelen, \ SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); } SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); } - SYS_FUTIMES = 206 // { int sys_futimes(int fd, \ SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); } + SYS_UTRACE = 209 // { int sys_utrace(const char *label, const void *addr, \ SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); } SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); } SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \ SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \ SYS_SHMAT = 228 // { void *sys_shmat(int shmid, const void *shmaddr, \ SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); } - SYS_CLOCK_GETTIME = 232 // { int sys_clock_gettime(clockid_t clock_id, \ - SYS_CLOCK_SETTIME = 233 // { int sys_clock_settime(clockid_t clock_id, \ - SYS_CLOCK_GETRES = 234 // { int sys_clock_getres(clockid_t clock_id, \ - SYS_NANOSLEEP = 240 // { int sys_nanosleep(const struct timespec *rqtp, \ SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, \ SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, \ SYS_ISSETUGID = 253 // { int sys_issetugid(void); } @@ -148,7 +164,6 @@ const ( SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, \ SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, \ SYS_KQUEUE = 269 // { int sys_kqueue(void); } - SYS_KEVENT = 270 // { int sys_kevent(int fd, \ SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); } SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); } SYS_GETRESUID = 281 // { int sys_getresuid(uid_t *ruid, uid_t *euid, \ @@ -160,32 +175,22 @@ const ( SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, \ SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); } SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, \ - SYS_STAT = 291 // { int sys_stat(const char *path, struct stat *ub); } - SYS_FSTAT = 292 // { int sys_fstat(int fd, struct stat *sb); } - SYS_LSTAT = 293 // { int sys_lstat(const char *path, struct stat *ub); } SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, \ SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, \ SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, \ SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, \ SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); } SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); } - SYS___THRSLEEP = 300 // { int sys___thrsleep(const volatile void *ident, \ SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, \ SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); } SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, \ SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); } SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, \ - SYS_GETFSSTAT = 306 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \ - SYS_STATFS = 307 // { int sys_statfs(const char *path, \ - SYS_FSTATFS = 308 // { int sys_fstatfs(int fd, struct statfs *buf); } - SYS_FHSTATFS = 309 // { int sys_fhstatfs(const fhandle_t *fhp, \ SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); } SYS_GETRTABLE = 311 // { int sys_getrtable(void); } - SYS_GETDIRENTRIES = 312 // { int sys_getdirentries(int fd, char *buf, \ SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, \ SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, \ SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, \ - SYS_FSTATAT = 316 // { int sys_fstatat(int fd, const char *path, \ SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, \ SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, \ SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, \ @@ -195,8 +200,6 @@ const ( SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, \ SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, \ SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, \ - SYS_UTIMENSAT = 326 // { int sys_utimensat(int fd, const char *path, \ - SYS_FUTIMENS = 327 // { int sys_futimens(int fd, \ SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); } SYS___GET_TCB = 330 // { void *sys___get_tcb(void); } ) diff --git a/src/pkg/syscall/zsysnum_solaris_amd64.go b/src/pkg/syscall/zsysnum_solaris_amd64.go new file mode 100644 index 000000000..43b3d8b40 --- /dev/null +++ b/src/pkg/syscall/zsysnum_solaris_amd64.go @@ -0,0 +1,11 @@ +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package syscall + +// TODO(aram): remove these before Go 1.3. +const ( + SYS_EXECVE = 59 + SYS_FCNTL = 62 +) diff --git a/src/pkg/syscall/ztypes_dragonfly_386.go b/src/pkg/syscall/ztypes_dragonfly_386.go index c467d8593..6b6ec1525 100644 --- a/src/pkg/syscall/ztypes_dragonfly_386.go +++ b/src/pkg/syscall/ztypes_dragonfly_386.go @@ -55,10 +55,6 @@ type Rlimit struct { type _Gid_t uint32 const ( - F_DUPFD_CLOEXEC = 0 -) - -const ( S_IFMT = 0xf000 S_IFIFO = 0x1000 S_IFCHR = 0x2000 @@ -427,3 +423,13 @@ type BpfHdr struct { Hdrlen uint16 Pad_cgo_0 [2]byte } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} diff --git a/src/pkg/syscall/ztypes_dragonfly_amd64.go b/src/pkg/syscall/ztypes_dragonfly_amd64.go index b71bf29f4..954ffd7ab 100644 --- a/src/pkg/syscall/ztypes_dragonfly_amd64.go +++ b/src/pkg/syscall/ztypes_dragonfly_amd64.go @@ -55,10 +55,6 @@ type Rlimit struct { type _Gid_t uint32 const ( - F_DUPFD_CLOEXEC = 0 -) - -const ( S_IFMT = 0xf000 S_IFIFO = 0x1000 S_IFCHR = 0x2000 @@ -433,3 +429,13 @@ type BpfHdr struct { Hdrlen uint16 Pad_cgo_0 [6]byte } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} diff --git a/src/pkg/syscall/ztypes_freebsd_386.go b/src/pkg/syscall/ztypes_freebsd_386.go index e77bd4b41..b809eea37 100644 --- a/src/pkg/syscall/ztypes_freebsd_386.go +++ b/src/pkg/syscall/ztypes_freebsd_386.go @@ -55,10 +55,6 @@ type Rlimit struct { type _Gid_t uint32 const ( - O_CLOEXEC = 0 -) - -const ( S_IFMT = 0xf000 S_IFIFO = 0x1000 S_IFCHR = 0x2000 @@ -282,7 +278,9 @@ type FdSet struct { } const ( + sizeofIfMsghdr = 0x64 SizeofIfMsghdr = 0x60 + sizeofIfData = 0x54 SizeofIfData = 0x50 SizeofIfaMsghdr = 0x14 SizeofIfmaMsghdr = 0x10 @@ -291,6 +289,17 @@ const ( SizeofRtMetrics = 0x38 ) +type ifMsghdr struct { + Msglen uint16 + Version uint8 + Type uint8 + Addrs int32 + Flags int32 + Index uint16 + Pad_cgo_0 [2]byte + Data ifData +} + type IfMsghdr struct { Msglen uint16 Version uint8 @@ -302,6 +311,34 @@ type IfMsghdr struct { Data IfData } +type ifData struct { + Type uint8 + Physical uint8 + Addrlen uint8 + Hdrlen uint8 + Link_state uint8 + Vhid uint8 + Baudrate_pf uint8 + Datalen uint8 + Mtu uint32 + Metric uint32 + Baudrate uint32 + Ipackets uint32 + Ierrors uint32 + Opackets uint32 + Oerrors uint32 + Collisions uint32 + Ibytes uint32 + Obytes uint32 + Imcasts uint32 + Omcasts uint32 + Iqdrops uint32 + Noproto uint32 + Hwassist uint64 + Epoch int32 + Lastchange Timeval +} + type IfData struct { Type uint8 Physical uint8 @@ -443,3 +480,13 @@ type BpfZbufHeader struct { User_gen uint32 X_bzh_pad [5]uint32 } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} diff --git a/src/pkg/syscall/ztypes_freebsd_amd64.go b/src/pkg/syscall/ztypes_freebsd_amd64.go index 922de2ce5..a05908aed 100644 --- a/src/pkg/syscall/ztypes_freebsd_amd64.go +++ b/src/pkg/syscall/ztypes_freebsd_amd64.go @@ -55,10 +55,6 @@ type Rlimit struct { type _Gid_t uint32 const ( - O_CLOEXEC = 0 -) - -const ( S_IFMT = 0xf000 S_IFIFO = 0x1000 S_IFCHR = 0x2000 @@ -284,7 +280,9 @@ type FdSet struct { } const ( + sizeofIfMsghdr = 0xa8 SizeofIfMsghdr = 0xa8 + sizeofIfData = 0x98 SizeofIfData = 0x98 SizeofIfaMsghdr = 0x14 SizeofIfmaMsghdr = 0x10 @@ -293,6 +291,17 @@ const ( SizeofRtMetrics = 0x70 ) +type ifMsghdr struct { + Msglen uint16 + Version uint8 + Type uint8 + Addrs int32 + Flags int32 + Index uint16 + Pad_cgo_0 [2]byte + Data ifData +} + type IfMsghdr struct { Msglen uint16 Version uint8 @@ -304,6 +313,34 @@ type IfMsghdr struct { Data IfData } +type ifData struct { + Type uint8 + Physical uint8 + Addrlen uint8 + Hdrlen uint8 + Link_state uint8 + Vhid uint8 + Baudrate_pf uint8 + Datalen uint8 + Mtu uint64 + Metric uint64 + Baudrate uint64 + Ipackets uint64 + Ierrors uint64 + Opackets uint64 + Oerrors uint64 + Collisions uint64 + Ibytes uint64 + Obytes uint64 + Imcasts uint64 + Omcasts uint64 + Iqdrops uint64 + Noproto uint64 + Hwassist uint64 + Epoch int64 + Lastchange Timeval +} + type IfData struct { Type uint8 Physical uint8 @@ -446,3 +483,13 @@ type BpfZbufHeader struct { User_gen uint32 X_bzh_pad [5]uint32 } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} diff --git a/src/pkg/syscall/ztypes_freebsd_arm.go b/src/pkg/syscall/ztypes_freebsd_arm.go index b1bf83b4c..9303816f9 100644 --- a/src/pkg/syscall/ztypes_freebsd_arm.go +++ b/src/pkg/syscall/ztypes_freebsd_arm.go @@ -1,5 +1,5 @@ // Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_freebsd.go +// cgo -godefs -- -fsigned-char types_freebsd.go package syscall @@ -19,13 +19,15 @@ type ( ) type Timespec struct { - Sec int64 - Nsec int32 + Sec int64 + Nsec int32 + Pad_cgo_0 [4]byte } type Timeval struct { - Sec int64 - Usec int32 + Sec int64 + Usec int32 + Pad_cgo_0 [4]byte } type Rusage struct { @@ -55,10 +57,6 @@ type Rlimit struct { type _Gid_t uint32 const ( - O_CLOEXEC = 0 // not supported -) - -const ( S_IFMT = 0xf000 S_IFIFO = 0x1000 S_IFCHR = 0x2000 @@ -93,7 +91,6 @@ type Stat_t struct { Gen uint32 Lspare int32 Birthtimespec Timespec - Pad_cgo_0 [4]byte } type Statfs_t struct { @@ -122,12 +119,13 @@ type Statfs_t struct { } type Flock_t struct { - Start int64 - Len int64 - Pid int32 - Type int16 - Whence int16 - Sysid int32 + Start int64 + Len int64 + Pid int32 + Type int16 + Whence int16 + Sysid int32 + Pad_cgo_0 [4]byte } type Dirent struct { @@ -160,22 +158,20 @@ type RawSockaddrInet6 struct { } type RawSockaddrUnix struct { - Len uint8 - Family uint8 - Path [104]int8 - Pad_cgo_0 [2]byte + Len uint8 + Family uint8 + Path [104]int8 } type RawSockaddrDatalink struct { - Len uint8 - Family uint8 - Index uint16 - Type uint8 - Nlen uint8 - Alen uint8 - Slen uint8 - Data [46]int8 - Pad_cgo_0 [2]byte + Len uint8 + Family uint8 + Index uint16 + Type uint8 + Nlen uint8 + Alen uint8 + Slen uint8 + Data [46]int8 } type RawSockaddr struct { @@ -251,8 +247,8 @@ const ( SizeofSockaddrInet4 = 0x10 SizeofSockaddrInet6 = 0x1c SizeofSockaddrAny = 0x6c - SizeofSockaddrUnix = 0x6c - SizeofSockaddrDatalink = 0x38 + SizeofSockaddrUnix = 0x6a + SizeofSockaddrDatalink = 0x36 SizeofLinger = 0x8 SizeofIPMreq = 0x8 SizeofIPMreqn = 0xc @@ -284,8 +280,10 @@ type FdSet struct { } const ( - SizeofIfMsghdr = 0x68 - SizeofIfData = 0x58 + sizeofIfMsghdr = 0x70 + SizeofIfMsghdr = 0x70 + sizeofIfData = 0x60 + SizeofIfData = 0x60 SizeofIfaMsghdr = 0x14 SizeofIfmaMsghdr = 0x10 SizeofIfAnnounceMsghdr = 0x18 @@ -293,6 +291,17 @@ const ( SizeofRtMetrics = 0x38 ) +type ifMsghdr struct { + Msglen uint16 + Version uint8 + Type uint8 + Addrs int32 + Flags int32 + Index uint16 + Pad_cgo_0 [2]byte + Data ifData +} + type IfMsghdr struct { Msglen uint16 Version uint8 @@ -304,13 +313,41 @@ type IfMsghdr struct { Data IfData } +type ifData struct { + Type uint8 + Physical uint8 + Addrlen uint8 + Hdrlen uint8 + Link_state uint8 + Vhid uint8 + Baudrate_pf uint8 + Datalen uint8 + Mtu uint32 + Metric uint32 + Baudrate uint32 + Ipackets uint32 + Ierrors uint32 + Opackets uint32 + Oerrors uint32 + Collisions uint32 + Ibytes uint32 + Obytes uint32 + Imcasts uint32 + Omcasts uint32 + Iqdrops uint32 + Noproto uint32 + Hwassist uint64 + Epoch int64 + Lastchange Timeval +} + type IfData struct { Type uint8 Physical uint8 Addrlen uint8 Hdrlen uint8 Link_state uint8 - Spare_char1 uint8 //Vhid uint8 + Spare_char1 uint8 Spare_char2 uint8 Datalen uint8 Mtu uint32 @@ -328,6 +365,7 @@ type IfData struct { Iqdrops uint32 Noproto uint32 Hwassist uint32 + Pad_cgo_0 [4]byte Epoch int64 Lastchange Timeval } @@ -399,7 +437,7 @@ const ( SizeofBpfZbuf = 0xc SizeofBpfProgram = 0x8 SizeofBpfInsn = 0x8 - SizeofBpfHdr = 0x18 + SizeofBpfHdr = 0x20 SizeofBpfZbufHeader = 0x20 ) @@ -436,7 +474,7 @@ type BpfHdr struct { Caplen uint32 Datalen uint32 Hdrlen uint16 - Pad_cgo_0 [2]byte + Pad_cgo_0 [6]byte } type BpfZbufHeader struct { @@ -445,3 +483,13 @@ type BpfZbufHeader struct { User_gen uint32 X_bzh_pad [5]uint32 } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed uint32 + Ospeed uint32 +} diff --git a/src/pkg/syscall/ztypes_linux_386.go b/src/pkg/syscall/ztypes_linux_386.go index 9abd647ac..daecb1ded 100644 --- a/src/pkg/syscall/ztypes_linux_386.go +++ b/src/pkg/syscall/ztypes_linux_386.go @@ -142,6 +142,14 @@ type Fsid struct { X__val [2]int32 } +type Flock_t struct { + Type int16 + Whence int16 + Start int64 + Len int64 + Pid int32 +} + type RawSockaddrInet4 struct { Family uint16 Port uint16 diff --git a/src/pkg/syscall/ztypes_linux_amd64.go b/src/pkg/syscall/ztypes_linux_amd64.go index 32da4e4b5..694fe1eac 100644 --- a/src/pkg/syscall/ztypes_linux_amd64.go +++ b/src/pkg/syscall/ztypes_linux_amd64.go @@ -142,6 +142,16 @@ type Fsid struct { X__val [2]int32 } +type Flock_t struct { + Type int16 + Whence int16 + Pad_cgo_0 [4]byte + Start int64 + Len int64 + Pid int32 + Pad_cgo_1 [4]byte +} + type RawSockaddrInet4 struct { Family uint16 Port uint16 diff --git a/src/pkg/syscall/ztypes_linux_arm.go b/src/pkg/syscall/ztypes_linux_arm.go index 4a918a8a7..5f21a948d 100644 --- a/src/pkg/syscall/ztypes_linux_arm.go +++ b/src/pkg/syscall/ztypes_linux_arm.go @@ -144,6 +144,16 @@ type Fsid struct { X__val [2]int32 } +type Flock_t struct { + Type int16 + Whence int16 + Pad_cgo_0 [4]byte + Start int64 + Len int64 + Pid int32 + Pad_cgo_1 [4]byte +} + type RawSockaddrInet4 struct { Family uint16 Port uint16 diff --git a/src/pkg/syscall/ztypes_netbsd_386.go b/src/pkg/syscall/ztypes_netbsd_386.go index 59314bad2..6add325a3 100644 --- a/src/pkg/syscall/ztypes_netbsd_386.go +++ b/src/pkg/syscall/ztypes_netbsd_386.go @@ -370,6 +370,16 @@ type BpfTimeval struct { Usec int32 } +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} + type Sysctlnode struct { Flags uint32 Num int32 diff --git a/src/pkg/syscall/ztypes_netbsd_amd64.go b/src/pkg/syscall/ztypes_netbsd_amd64.go index a021a5738..4451fc1f0 100644 --- a/src/pkg/syscall/ztypes_netbsd_amd64.go +++ b/src/pkg/syscall/ztypes_netbsd_amd64.go @@ -377,6 +377,16 @@ type BpfTimeval struct { Usec int64 } +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} + type Sysctlnode struct { Flags uint32 Num int32 diff --git a/src/pkg/syscall/ztypes_netbsd_arm.go b/src/pkg/syscall/ztypes_netbsd_arm.go index 59314bad2..4e853eaa2 100644 --- a/src/pkg/syscall/ztypes_netbsd_arm.go +++ b/src/pkg/syscall/ztypes_netbsd_arm.go @@ -19,13 +19,15 @@ type ( ) type Timespec struct { - Sec int64 - Nsec int32 + Sec int64 + Nsec int32 + Pad_cgo_0 [4]byte } type Timeval struct { - Sec int64 - Usec int32 + Sec int64 + Usec int32 + Pad_cgo_0 [4]byte } type Rusage struct { @@ -57,10 +59,12 @@ type _Gid_t uint32 type Stat_t struct { Dev uint64 Mode uint32 + Pad_cgo_0 [4]byte Ino uint64 Nlink uint32 Uid uint32 Gid uint32 + Pad_cgo_1 [4]byte Rdev uint64 Atimespec Timespec Mtimespec Timespec @@ -72,6 +76,7 @@ type Stat_t struct { Flags uint32 Gen uint32 Spare [2]uint32 + Pad_cgo_2 [4]byte } type Statfs_t [0]byte @@ -217,12 +222,13 @@ const ( ) type Kevent_t struct { - Ident uint32 - Filter uint32 - Flags uint32 - Fflags uint32 - Data int64 - Udata int32 + Ident uint32 + Filter uint32 + Flags uint32 + Fflags uint32 + Data int64 + Udata int32 + Pad_cgo_0 [4]byte } type FdSet struct { @@ -231,7 +237,7 @@ type FdSet struct { const ( SizeofIfMsghdr = 0x98 - SizeofIfData = 0x84 + SizeofIfData = 0x88 SizeofIfaMsghdr = 0x18 SizeofIfAnnounceMsghdr = 0x18 SizeofRtMsghdr = 0x78 @@ -247,7 +253,6 @@ type IfMsghdr struct { Index uint16 Pad_cgo_0 [2]byte Data IfData - Pad_cgo_1 [4]byte } type IfData struct { @@ -370,6 +375,16 @@ type BpfTimeval struct { Usec int32 } +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} + type Sysctlnode struct { Flags uint32 Num int32 diff --git a/src/pkg/syscall/ztypes_openbsd_386.go b/src/pkg/syscall/ztypes_openbsd_386.go index 3c9cdf28b..2e4d9dd17 100644 --- a/src/pkg/syscall/ztypes_openbsd_386.go +++ b/src/pkg/syscall/ztypes_openbsd_386.go @@ -19,12 +19,12 @@ type ( ) type Timespec struct { - Sec int32 + Sec int64 Nsec int32 } type Timeval struct { - Sec int32 + Sec int64 Usec int32 } @@ -72,14 +72,13 @@ const ( ) type Stat_t struct { - Dev int32 - Ino uint32 Mode uint32 + Dev int32 + Ino uint64 Nlink uint32 Uid uint32 Gid uint32 Rdev int32 - Lspare0 int32 Atim Timespec Mtim Timespec Ctim Timespec @@ -88,9 +87,7 @@ type Stat_t struct { Blksize uint32 Flags uint32 Gen uint32 - Lspare1 int32 X__st_birthtim Timespec - Qspare [2]int64 } type Statfs_t struct { @@ -110,11 +107,12 @@ type Statfs_t struct { F_fsid Fsid F_namemax uint32 F_owner uint32 - F_ctime uint32 - F_spare [3]uint32 + F_ctime uint64 F_fstypename [16]int8 F_mntonname [90]int8 F_mntfromname [90]int8 + F_mntfromspec [90]int8 + Pad_cgo_0 [2]byte Mount_info [160]byte } @@ -127,11 +125,13 @@ type Flock_t struct { } type Dirent struct { - Fileno uint32 - Reclen uint16 - Type uint8 - Namlen uint8 - Name [256]int8 + Fileno uint64 + Off int64 + Reclen uint16 + Type uint8 + Namlen uint8 + X__d_padding [4]uint8 + Name [256]int8 } type Fsid struct { @@ -262,21 +262,21 @@ type Kevent_t struct { Filter int16 Flags uint16 Fflags uint32 - Data int32 + Data int64 Udata *byte } type FdSet struct { - Bits [32]int32 + Bits [32]uint32 } const ( - SizeofIfMsghdr = 0xe8 - SizeofIfData = 0xd0 + SizeofIfMsghdr = 0xec + SizeofIfData = 0xd4 SizeofIfaMsghdr = 0x18 SizeofIfAnnounceMsghdr = 0x1a - SizeofRtMsghdr = 0x58 - SizeofRtMetrics = 0x30 + SizeofRtMsghdr = 0x60 + SizeofRtMetrics = 0x38 ) type IfMsghdr struct { @@ -364,9 +364,9 @@ type RtMsghdr struct { type RtMetrics struct { Pksent uint64 + Expire int64 Locks uint32 Mtu uint32 - Expire uint32 Refcnt uint32 Hopcount uint32 Recvpipe uint32 @@ -374,10 +374,11 @@ type RtMetrics struct { Ssthresh uint32 Rtt uint32 Rttvar uint32 + Pad uint32 } type Mclpool struct { - Grown uint32 + Grown int32 Alive uint16 Hwm uint16 Cwm uint16 @@ -426,3 +427,13 @@ type BpfTimeval struct { Sec uint32 Usec uint32 } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} diff --git a/src/pkg/syscall/ztypes_openbsd_amd64.go b/src/pkg/syscall/ztypes_openbsd_amd64.go index 3a0ac96fa..f07bc714e 100644 --- a/src/pkg/syscall/ztypes_openbsd_amd64.go +++ b/src/pkg/syscall/ztypes_openbsd_amd64.go @@ -19,9 +19,8 @@ type ( ) type Timespec struct { - Sec int32 - Pad_cgo_0 [4]byte - Nsec int64 + Sec int64 + Nsec int64 } type Timeval struct { @@ -73,14 +72,13 @@ const ( ) type Stat_t struct { - Dev int32 - Ino uint32 Mode uint32 + Dev int32 + Ino uint64 Nlink uint32 Uid uint32 Gid uint32 Rdev int32 - Lspare0 int32 Atim Timespec Mtim Timespec Ctim Timespec @@ -89,9 +87,8 @@ type Stat_t struct { Blksize uint32 Flags uint32 Gen uint32 - Lspare1 int32 + Pad_cgo_0 [4]byte X__st_birthtim Timespec - Qspare [2]int64 } type Statfs_t struct { @@ -112,12 +109,12 @@ type Statfs_t struct { F_fsid Fsid F_namemax uint32 F_owner uint32 - F_ctime uint32 - F_spare [3]uint32 + F_ctime uint64 F_fstypename [16]int8 F_mntonname [90]int8 F_mntfromname [90]int8 - Pad_cgo_1 [4]byte + F_mntfromspec [90]int8 + Pad_cgo_1 [2]byte Mount_info [160]byte } @@ -130,11 +127,13 @@ type Flock_t struct { } type Dirent struct { - Fileno uint32 - Reclen uint16 - Type uint8 - Namlen uint8 - Name [256]int8 + Fileno uint64 + Off int64 + Reclen uint16 + Type uint8 + Namlen uint8 + X__d_padding [4]uint8 + Name [256]int8 } type Fsid struct { @@ -263,16 +262,16 @@ const ( ) type Kevent_t struct { - Ident uint32 + Ident uint64 Filter int16 Flags uint16 Fflags uint32 - Data int32 + Data int64 Udata *byte } type FdSet struct { - Bits [32]int32 + Bits [32]uint32 } const ( @@ -280,8 +279,8 @@ const ( SizeofIfData = 0xe0 SizeofIfaMsghdr = 0x18 SizeofIfAnnounceMsghdr = 0x1a - SizeofRtMsghdr = 0x58 - SizeofRtMetrics = 0x30 + SizeofRtMsghdr = 0x60 + SizeofRtMetrics = 0x38 ) type IfMsghdr struct { @@ -371,9 +370,9 @@ type RtMsghdr struct { type RtMetrics struct { Pksent uint64 + Expire int64 Locks uint32 Mtu uint32 - Expire uint32 Refcnt uint32 Hopcount uint32 Recvpipe uint32 @@ -381,10 +380,11 @@ type RtMetrics struct { Ssthresh uint32 Rtt uint32 Rttvar uint32 + Pad uint32 } type Mclpool struct { - Grown uint32 + Grown int32 Alive uint16 Hwm uint16 Cwm uint16 @@ -434,3 +434,13 @@ type BpfTimeval struct { Sec uint32 Usec uint32 } + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [20]uint8 + Ispeed int32 + Ospeed int32 +} diff --git a/src/pkg/syscall/ztypes_solaris_amd64.go b/src/pkg/syscall/ztypes_solaris_amd64.go new file mode 100644 index 000000000..77275a54e --- /dev/null +++ b/src/pkg/syscall/ztypes_solaris_amd64.go @@ -0,0 +1,365 @@ +// Created by cgo -godefs - DO NOT EDIT +// cgo -godefs types_solaris.go + +package syscall + +const ( + sizeofPtr = 0x8 + sizeofShort = 0x2 + sizeofInt = 0x4 + sizeofLong = 0x8 + sizeofLongLong = 0x8 +) + +type ( + _C_short int16 + _C_int int32 + _C_long int64 + _C_long_long int64 +) + +type Timespec struct { + Sec int64 + Nsec int64 +} + +type Timeval struct { + Sec int64 + Usec int64 +} + +type Timeval32 struct { + Sec int32 + Usec int32 +} + +type Rusage struct { + Utime Timeval + Stime Timeval + Maxrss int64 + Ixrss int64 + Idrss int64 + Isrss int64 + Minflt int64 + Majflt int64 + Nswap int64 + Inblock int64 + Oublock int64 + Msgsnd int64 + Msgrcv int64 + Nsignals int64 + Nvcsw int64 + Nivcsw int64 +} + +type Rlimit struct { + Cur uint64 + Max uint64 +} + +type _Gid_t uint32 + +const ( + S_IFMT = 0xf000 + S_IFIFO = 0x1000 + S_IFCHR = 0x2000 + S_IFDIR = 0x4000 + S_IFBLK = 0x6000 + S_IFREG = 0x8000 + S_IFLNK = 0xa000 + S_IFSOCK = 0xc000 + S_ISUID = 0x800 + S_ISGID = 0x400 + S_ISVTX = 0x200 + S_IRUSR = 0x100 + S_IWUSR = 0x80 + S_IXUSR = 0x40 +) + +type Stat_t struct { + Dev uint64 + Ino uint64 + Mode uint32 + Nlink uint32 + Uid uint32 + Gid uint32 + Rdev uint64 + Size int64 + Atim Timespec + Mtim Timespec + Ctim Timespec + Blksize int32 + Pad_cgo_0 [4]byte + Blocks int64 + Fstype [16]int8 +} + +type Flock_t struct { + Type int16 + Whence int16 + Pad_cgo_0 [4]byte + Start int64 + Len int64 + Sysid int32 + Pid int32 + Pad [4]int64 +} + +type Dirent struct { + Ino uint64 + Off int64 + Reclen uint16 + Name [1]int8 + Pad_cgo_0 [5]byte +} + +type RawSockaddrInet4 struct { + Family uint16 + Port uint16 + Addr [4]byte /* in_addr */ + Zero [8]int8 +} + +type RawSockaddrInet6 struct { + Family uint16 + Port uint16 + Flowinfo uint32 + Addr [16]byte /* in6_addr */ + Scope_id uint32 + X__sin6_src_id uint32 +} + +type RawSockaddrUnix struct { + Family uint16 + Path [108]int8 +} + +type RawSockaddrDatalink struct { + Family uint16 + Index uint16 + Type uint8 + Nlen uint8 + Alen uint8 + Slen uint8 + Data [244]int8 +} + +type RawSockaddr struct { + Family uint16 + Data [14]int8 +} + +type RawSockaddrAny struct { + Addr RawSockaddr + Pad [236]int8 +} + +type _Socklen uint32 + +type Linger struct { + Onoff int32 + Linger int32 +} + +type Iovec struct { + Base *int8 + Len uint64 +} + +type IPMreq struct { + Multiaddr [4]byte /* in_addr */ + Interface [4]byte /* in_addr */ +} + +type IPv6Mreq struct { + Multiaddr [16]byte /* in6_addr */ + Interface uint32 +} + +type Msghdr struct { + Name *byte + Namelen uint32 + Pad_cgo_0 [4]byte + Iov *Iovec + Iovlen int32 + Pad_cgo_1 [4]byte + Accrights *int8 + Accrightslen int32 + Pad_cgo_2 [4]byte +} + +type Cmsghdr struct { + Len uint32 + Level int32 + Type int32 +} + +type Inet6Pktinfo struct { + Addr [16]byte /* in6_addr */ + Ifindex uint32 +} + +type IPv6MTUInfo struct { + Addr RawSockaddrInet6 + Mtu uint32 +} + +type ICMPv6Filter struct { + X__icmp6_filt [8]uint32 +} + +const ( + SizeofSockaddrInet4 = 0x10 + SizeofSockaddrInet6 = 0x20 + SizeofSockaddrAny = 0xfc + SizeofSockaddrUnix = 0x6e + SizeofSockaddrDatalink = 0xfc + SizeofLinger = 0x8 + SizeofIPMreq = 0x8 + SizeofIPv6Mreq = 0x14 + SizeofMsghdr = 0x30 + SizeofCmsghdr = 0xc + SizeofInet6Pktinfo = 0x14 + SizeofIPv6MTUInfo = 0x24 + SizeofICMPv6Filter = 0x20 +) + +type FdSet struct { + Bits [1024]int64 +} + +const ( + SizeofIfMsghdr = 0x54 + SizeofIfData = 0x44 + SizeofIfaMsghdr = 0x14 + SizeofRtMsghdr = 0x4c + SizeofRtMetrics = 0x28 +) + +type IfMsghdr struct { + Msglen uint16 + Version uint8 + Type uint8 + Addrs int32 + Flags int32 + Index uint16 + Pad_cgo_0 [2]byte + Data IfData +} + +type IfData struct { + Type uint8 + Addrlen uint8 + Hdrlen uint8 + Pad_cgo_0 [1]byte + Mtu uint32 + Metric uint32 + Baudrate uint32 + Ipackets uint32 + Ierrors uint32 + Opackets uint32 + Oerrors uint32 + Collisions uint32 + Ibytes uint32 + Obytes uint32 + Imcasts uint32 + Omcasts uint32 + Iqdrops uint32 + Noproto uint32 + Lastchange Timeval32 +} + +type IfaMsghdr struct { + Msglen uint16 + Version uint8 + Type uint8 + Addrs int32 + Flags int32 + Index uint16 + Pad_cgo_0 [2]byte + Metric int32 +} + +type RtMsghdr struct { + Msglen uint16 + Version uint8 + Type uint8 + Index uint16 + Pad_cgo_0 [2]byte + Flags int32 + Addrs int32 + Pid int32 + Seq int32 + Errno int32 + Use int32 + Inits uint32 + Rmx RtMetrics +} + +type RtMetrics struct { + Locks uint32 + Mtu uint32 + Hopcount uint32 + Expire uint32 + Recvpipe uint32 + Sendpipe uint32 + Ssthresh uint32 + Rtt uint32 + Rttvar uint32 + Pksent uint32 +} + +const ( + SizeofBpfVersion = 0x4 + SizeofBpfStat = 0x80 + SizeofBpfProgram = 0x10 + SizeofBpfInsn = 0x8 + SizeofBpfHdr = 0x14 +) + +type BpfVersion struct { + Major uint16 + Minor uint16 +} + +type BpfStat struct { + Recv uint64 + Drop uint64 + Capt uint64 + Padding [13]uint64 +} + +type BpfProgram struct { + Len uint32 + Pad_cgo_0 [4]byte + Insns *BpfInsn +} + +type BpfInsn struct { + Code uint16 + Jt uint8 + Jf uint8 + K uint32 +} + +type BpfTimeval struct { + Sec int32 + Usec int32 +} + +type BpfHdr struct { + Tstamp BpfTimeval + Caplen uint32 + Datalen uint32 + Hdrlen uint16 + Pad_cgo_0 [2]byte +} + +type Termios struct { + Iflag uint32 + Oflag uint32 + Cflag uint32 + Lflag uint32 + Cc [19]uint8 + Pad_cgo_0 [1]byte +} diff --git a/src/pkg/syscall/ztypes_windows.go b/src/pkg/syscall/ztypes_windows.go index a5681d700..a1d77e0b5 100644 --- a/src/pkg/syscall/ztypes_windows.go +++ b/src/pkg/syscall/ztypes_windows.go @@ -20,6 +20,7 @@ const ( ERROR_PROC_NOT_FOUND Errno = 127 ERROR_ALREADY_EXISTS Errno = 183 ERROR_ENVVAR_NOT_FOUND Errno = 203 + ERROR_MORE_DATA Errno = 234 ERROR_OPERATION_ABORTED Errno = 995 ERROR_IO_PENDING Errno = 997 ERROR_NOT_FOUND Errno = 1168 @@ -514,9 +515,11 @@ const ( IOC_OUT = 0x40000000 IOC_IN = 0x80000000 + IOC_VENDOR = 0x18000000 IOC_INOUT = IOC_IN | IOC_OUT IOC_WS2 = 0x08000000 SIO_GET_EXTENSION_FUNCTION_POINTER = IOC_INOUT | IOC_WS2 | 6 + SIO_KEEPALIVE_VALS = IOC_IN | IOC_VENDOR | 4 // cf. http://support.microsoft.com/default.aspx?scid=kb;en-us;257460 @@ -1033,3 +1036,9 @@ type WSAProtocolChain struct { ChainLen int32 ChainEntries [MAX_PROTOCOL_CHAIN]uint32 } + +type TCPKeepalive struct { + OnOff uint32 + Time uint32 + Interval uint32 +} |