syscall: fix mkall.sh, mksyscall_linux.pl, and regen for Linux/ARM
CL 3075041 says ARM is not little-endian, but my test suggests otherwise.
My test program is:
package main
import ("fmt"; "syscall"; "os")
func main() {
err := syscall.Fallocate(1, 1/*FALLOC_FL_KEEP_SIZE*/, 0, int64(40960));
fmt.Fprintln(os.Stderr, err)
}
Without this CL, ./test > testfile will show: file too large; and strace shows:
fallocate(1, 01, 0, 175921860444160) = -1 EFBIG (File too large)
With this CL, ./test > testfile will show: <nil>; and strace shows:
fallocate(1, 01, 0, 40960) = 0
Quoting rsc:
"[It turns out that] ARM syscall ABI requires 64-bit arguments to use an
(even, odd) register pair, not an (odd, even) pair. Switching to "big-endian"
worked because it ended up using the high 32-bits (always zero in the tests
we had) as the padding word, because the 64-bit argument was the last one,
and because we fill in zeros for the rest of the system call arguments, up to
six. So it happened to work."
I updated mksyscall_linux.pl to accommodate the register pair ABI requirement,
and removed all hand-tweaked syscall routines in favor of the auto-generated
ones. These including: Ftruncate, Truncate, Pread and Pwrite.
Some recent Linux/ARM distributions do not bundle kernel asm headers,
so instead we always get latest asm/unistd.h from git.kernel.org (just like
what we do for FreeBSD).
R=ken, r, rsc, r, dave, iant
CC=golang-dev
https://golang.org/cl/5726051
2012-03-05 12:12:11 -07:00
|
|
|
// mksyscall.pl -l32 -arm syscall_linux.go syscall_linux_arm.go
|
2009-08-18 20:20:33 -06:00
|
|
|
// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
|
|
|
|
|
|
|
|
package syscall
|
|
|
|
|
|
|
|
import "unsafe"
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func open(path string, mode int, perm uint32) (fd int, err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
|
2010-05-03 12:11:01 -06:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-05-03 12:11:01 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0)
|
2010-05-03 12:11:01 -06:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-05-03 12:11:01 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func pipe(p *[2]_C_int) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2013-01-10 18:04:55 -07:00
|
|
|
func pipe2(p *[2]_C_int, flags int) (err error) {
|
|
|
|
_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func utimes(path string, times *[2]Timeval) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-12-13 14:02:39 -07:00
|
|
|
func utimensat(dirfd int, path string, times *[2]Timespec) (err error) {
|
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)))
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func futimesat(dirfd int, path *byte, times *[2]Timeval) (err error) {
|
2010-05-21 15:33:17 -06:00
|
|
|
_, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(times)))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Getcwd(buf []byte) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(buf) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&buf[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall(SYS_GETCWD, uintptr(_p0), uintptr(len(buf)), 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
|
|
|
|
wpid = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(arg)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-03-09 06:45:08 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(source)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(target)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p2 *byte
|
|
|
|
_p2, err = BytePtrFromString(fstype)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-10-14 10:19:45 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Access(path string, mode uint32) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Acct(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Adjtimex(buf *Timex) (state int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0)
|
|
|
|
state = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Chdir(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Chmod(path string, mode uint32) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Chroot(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Close(fd int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Creat(path string, mode uint32) (fd int, err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall(SYS_CREAT, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Dup(oldfd int) (fd int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_DUP, uintptr(oldfd), 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-02-12 22:11:36 -07:00
|
|
|
func Dup2(oldfd int, newfd int) (err error) {
|
|
|
|
_, _, e1 := RawSyscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func EpollCreate(size int) (fd int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE, uintptr(size), 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-12-19 13:57:49 -07:00
|
|
|
func EpollCreate1(flag int) (fd int, err error) {
|
|
|
|
r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE1, uintptr(flag), 0, 0)
|
|
|
|
fd = int(r0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(events) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&events[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall6(SYS_EPOLL_WAIT, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-10-06 20:38:30 -06:00
|
|
|
func Exit(code int) {
|
2009-12-15 16:40:16 -07:00
|
|
|
Syscall(SYS_EXIT_GROUP, uintptr(code), 0, 0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fallocate(fd int, mode uint32, off int64, len int64) (err error) {
|
syscall: fix mkall.sh, mksyscall_linux.pl, and regen for Linux/ARM
CL 3075041 says ARM is not little-endian, but my test suggests otherwise.
My test program is:
package main
import ("fmt"; "syscall"; "os")
func main() {
err := syscall.Fallocate(1, 1/*FALLOC_FL_KEEP_SIZE*/, 0, int64(40960));
fmt.Fprintln(os.Stderr, err)
}
Without this CL, ./test > testfile will show: file too large; and strace shows:
fallocate(1, 01, 0, 175921860444160) = -1 EFBIG (File too large)
With this CL, ./test > testfile will show: <nil>; and strace shows:
fallocate(1, 01, 0, 40960) = 0
Quoting rsc:
"[It turns out that] ARM syscall ABI requires 64-bit arguments to use an
(even, odd) register pair, not an (odd, even) pair. Switching to "big-endian"
worked because it ended up using the high 32-bits (always zero in the tests
we had) as the padding word, because the 64-bit argument was the last one,
and because we fill in zeros for the rest of the system call arguments, up to
six. So it happened to work."
I updated mksyscall_linux.pl to accommodate the register pair ABI requirement,
and removed all hand-tweaked syscall routines in favor of the auto-generated
ones. These including: Ftruncate, Truncate, Pread and Pwrite.
Some recent Linux/ARM distributions do not bundle kernel asm headers,
so instead we always get latest asm/unistd.h from git.kernel.org (just like
what we do for FreeBSD).
R=ken, r, rsc, r, dave, iant
CC=golang-dev
https://golang.org/cl/5726051
2012-03-05 12:12:11 -07:00
|
|
|
_, _, e1 := Syscall6(SYS_FALLOCATE, uintptr(fd), uintptr(mode), uintptr(off), uintptr(off>>32), uintptr(len), uintptr(len>>32))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fchdir(fd int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fchmod(fd int, mode uint32) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func fcntl(fd int, cmd int, arg int) (val int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
|
|
|
|
val = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fdatasync(fd int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_FDATASYNC, uintptr(fd), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Flock(fd int, how int) (err error) {
|
2011-07-13 16:34:36 -06:00
|
|
|
_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-07-13 16:34:36 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fsync(fd int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Getdents(fd int, buf []byte) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(buf) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&buf[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall(SYS_GETDENTS64, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Getpgid(pid int) (pgid int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
pgid = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-08-18 20:20:33 -06:00
|
|
|
func Getpgrp() (pid int) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
pid = int(r0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-08-18 20:20:33 -06:00
|
|
|
func Getpid() (pid int) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
pid = int(r0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-08-18 20:20:33 -06:00
|
|
|
func Getppid() (ppid int) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
ppid = int(r0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Getrusage(who int, rusage *Rusage) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-08-18 20:20:33 -06:00
|
|
|
func Gettid() (tid int) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETTID, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
tid = int(r0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-11-01 12:49:38 -06:00
|
|
|
func Getxattr(path string, attr string, dest []byte) (sz int, err error) {
|
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(attr)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p2 unsafe.Pointer
|
|
|
|
if len(dest) > 0 {
|
|
|
|
_p2 = unsafe.Pointer(&dest[0])
|
|
|
|
} else {
|
|
|
|
_p2 = unsafe.Pointer(&_zero)
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0)
|
|
|
|
sz = int(r0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(pathname)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask))
|
2010-09-27 09:44:26 -06:00
|
|
|
watchdesc = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-09-27 09:44:26 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func InotifyInit() (fd int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0)
|
2010-09-27 09:44:26 -06:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-09-27 09:44:26 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func InotifyInit1(flags int) (fd int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT1, uintptr(flags), 0, 0)
|
2010-09-27 09:44:26 -06:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-09-27 09:44:26 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_INOTIFY_RM_WATCH, uintptr(fd), uintptr(watchdesc), 0)
|
2010-09-27 09:44:26 -06:00
|
|
|
success = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-09-27 09:44:26 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
os/signal: selective signal handling
Restore package os/signal, with new API:
Notify replaces Incoming, allowing clients
to ask for certain signals only. Also, signals
go to everyone who asks, not just one client.
This could plausibly move into package os now
that there are no magic side effects as a result
of the import.
Update runtime for new API: move common Unix
signal handling code into signal_unix.c.
(It's so easy to do this now that we don't have
to edit Makefiles!)
Tested on darwin,linux 386,amd64.
Fixes #1266.
R=r, dsymonds, bradfitz, iant, borman
CC=golang-dev
https://golang.org/cl/3749041
2012-02-13 11:52:37 -07:00
|
|
|
func Kill(pid int, sig Signal) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Klogctl(typ int, buf []byte) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(buf) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&buf[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(_p0), uintptr(len(buf)))
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Link(oldpath string, newpath string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(oldpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(newpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-11-01 12:49:38 -06:00
|
|
|
func Listxattr(path string, dest []byte) (sz int, err error) {
|
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 unsafe.Pointer
|
|
|
|
if len(dest) > 0 {
|
|
|
|
_p1 = unsafe.Pointer(&dest[0])
|
|
|
|
} else {
|
|
|
|
_p1 = unsafe.Pointer(&_zero)
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)))
|
|
|
|
sz = int(r0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mkdir(path string, mode uint32) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mkdirat(dirfd int, path string, mode uint32) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mknod(path string, mode uint32, dev int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mknodat(dirfd int, path string, mode uint32, dev int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Nanosleep(time *Timespec, leftover *Timespec) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Pause() (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_PAUSE, 0, 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func PivotRoot(newroot string, putold string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(newroot)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(putold)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
2009-08-18 20:20:33 -06:00
|
|
|
|
2012-07-30 16:21:24 -06:00
|
|
|
func prlimit(pid int, resource int, old *Rlimit, newlimit *Rlimit) (err error) {
|
2012-07-02 23:57:32 -06:00
|
|
|
_, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(newlimit)), 0, 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-10-09 10:51:58 -06:00
|
|
|
func read(fd int, p []byte) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(p) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Readlink(path string, buf []byte) (n int, err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(buf) > 0 {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
_p1 = unsafe.Pointer(&buf[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
_p1 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-11-01 12:49:38 -06:00
|
|
|
func Removexattr(path string, attr string) (err error) {
|
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(attr)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Rename(oldpath string, newpath string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(oldpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(newpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(oldpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(newpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Rmdir(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setdomainname(p []byte) (err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(p) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
_, _, e1 := Syscall(SYS_SETDOMAINNAME, uintptr(_p0), uintptr(len(p)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Sethostname(p []byte) (err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(p) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
_, _, e1 := Syscall(SYS_SETHOSTNAME, uintptr(_p0), uintptr(len(p)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setpgid(pid int, pgid int) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setsid() (pid int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
pid = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Settimeofday(tv *Timeval) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setuid(uid int) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-11-01 12:49:38 -06:00
|
|
|
func Setxattr(path string, attr string, data []byte, flags int) (err error) {
|
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(attr)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p2 unsafe.Pointer
|
|
|
|
if len(data) > 0 {
|
|
|
|
_p2 = unsafe.Pointer(&data[0])
|
|
|
|
} else {
|
|
|
|
_p2 = unsafe.Pointer(&_zero)
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Symlink(oldpath string, newpath string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(oldpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var _p1 *byte
|
|
|
|
_p1, err = BytePtrFromString(newpath)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-10-06 20:38:30 -06:00
|
|
|
func Sync() {
|
2009-12-15 16:40:16 -07:00
|
|
|
Syscall(SYS_SYNC, 0, 0, 0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Sysinfo(info *Sysinfo_t) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, r1, e1 := Syscall6(SYS_TEE, uintptr(rfd), uintptr(wfd), uintptr(len), uintptr(flags), 0, 0)
|
syscall: fix mkall.sh, mksyscall_linux.pl, and regen for Linux/ARM
CL 3075041 says ARM is not little-endian, but my test suggests otherwise.
My test program is:
package main
import ("fmt"; "syscall"; "os")
func main() {
err := syscall.Fallocate(1, 1/*FALLOC_FL_KEEP_SIZE*/, 0, int64(40960));
fmt.Fprintln(os.Stderr, err)
}
Without this CL, ./test > testfile will show: file too large; and strace shows:
fallocate(1, 01, 0, 175921860444160) = -1 EFBIG (File too large)
With this CL, ./test > testfile will show: <nil>; and strace shows:
fallocate(1, 01, 0, 40960) = 0
Quoting rsc:
"[It turns out that] ARM syscall ABI requires 64-bit arguments to use an
(even, odd) register pair, not an (odd, even) pair. Switching to "big-endian"
worked because it ended up using the high 32-bits (always zero in the tests
we had) as the padding word, because the 64-bit argument was the last one,
and because we fill in zeros for the rest of the system call arguments, up to
six. So it happened to work."
I updated mksyscall_linux.pl to accommodate the register pair ABI requirement,
and removed all hand-tweaked syscall routines in favor of the auto-generated
ones. These including: Ftruncate, Truncate, Pread and Pwrite.
Some recent Linux/ARM distributions do not bundle kernel asm headers,
so instead we always get latest asm/unistd.h from git.kernel.org (just like
what we do for FreeBSD).
R=ken, r, rsc, r, dave, iant
CC=golang-dev
https://golang.org/cl/5726051
2012-03-05 12:12:11 -07:00
|
|
|
n = int64(int64(r1)<<32 | int64(r0))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-02-14 11:07:14 -07:00
|
|
|
func Tgkill(tgid int, tid int, sig Signal) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_TGKILL, uintptr(tgid), uintptr(tid), uintptr(sig))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Times(tms *Tms) (ticks uintptr, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
ticks = uintptr(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-08-18 20:20:33 -06:00
|
|
|
func Umask(mask int) (oldmask int) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_UMASK, uintptr(mask), 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
oldmask = int(r0)
|
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Uname(buf *Utsname) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Unlink(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Unlinkat(dirfd int, path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Unmount(target string, flags int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(target)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-03-09 06:58:47 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Unshare(flags int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_UNSHARE, uintptr(flags), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Ustat(dev int, ubuf *Ustat_t) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Utime(path string, buf *Utimbuf) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_UTIME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-10-09 10:51:58 -06:00
|
|
|
func write(fd int, p []byte) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-10-06 20:38:30 -06:00
|
|
|
if len(p) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-10-06 20:38:30 -06:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func exitThread(code int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_EXIT, uintptr(code), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-10-09 10:51:58 -06:00
|
|
|
func readlen(fd int, p *byte, np int) (n int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
|
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-10-09 10:51:58 -06:00
|
|
|
func writelen(fd int, p *byte, np int) (n int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np))
|
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func munmap(addr uintptr, length uintptr) (err error) {
|
2011-04-06 15:52:02 -06:00
|
|
|
_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-06 15:52:02 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Madvise(b []byte, advice int) (err error) {
|
2011-04-21 08:23:11 -06:00
|
|
|
var _p0 unsafe.Pointer
|
|
|
|
if len(b) > 0 {
|
|
|
|
_p0 = unsafe.Pointer(&b[0])
|
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(advice))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-21 08:23:11 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mprotect(b []byte, prot int) (err error) {
|
2011-04-21 08:23:11 -06:00
|
|
|
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))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-21 08:23:11 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mlock(b []byte) (err error) {
|
2011-04-26 07:41:19 -06:00
|
|
|
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)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-26 07:41:19 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Munlock(b []byte) (err error) {
|
2011-04-26 07:41:19 -06:00
|
|
|
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)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-26 07:41:19 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Mlockall(flags int) (err error) {
|
2011-04-26 07:41:19 -06:00
|
|
|
_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-26 07:41:19 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Munlockall() (err error) {
|
2011-04-26 07:41:19 -06:00
|
|
|
_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-26 07:41:19 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
|
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func bind(s int, addr uintptr, addrlen _Socklen) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func connect(s int, addr uintptr, addrlen _Socklen) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func getgroups(n int, list *_Gid_t) (nn int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_GETGROUPS32, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
nn = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func setgroups(n int, list *_Gid_t) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETGROUPS32, uintptr(n), uintptr(unsafe.Pointer(list)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) {
|
2011-03-23 12:33:48 -06:00
|
|
|
_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-03-23 12:33:48 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func setsockopt(s int, level int, name int, val uintptr, vallen uintptr) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func socket(domain int, typ int, proto int) (fd int, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
|
2009-12-15 16:40:16 -07:00
|
|
|
fd = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-12-13 14:05:49 -07:00
|
|
|
if len(p) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-12-13 14:05:49 -07:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
|
2009-12-15 16:40:16 -07:00
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-12-13 14:05:49 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (err error) {
|
2010-09-21 07:49:56 -06:00
|
|
|
var _p0 unsafe.Pointer
|
2009-12-13 14:05:49 -07:00
|
|
|
if len(buf) > 0 {
|
2010-09-21 07:49:56 -06:00
|
|
|
_p0 = unsafe.Pointer(&buf[0])
|
2011-02-09 12:28:47 -07:00
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
2009-12-13 14:05:49 -07:00
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-12-13 14:05:49 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2012-09-23 22:06:22 -06:00
|
|
|
func socketpair(domain int, typ int, flags int, fd *[2]int32) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-08-23 04:25:14 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
|
2010-12-08 14:49:49 -07:00
|
|
|
r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
|
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-12-08 14:49:49 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func sendmsg(s int, msg *Msghdr, flags int) (err error) {
|
2010-12-08 14:49:49 -07:00
|
|
|
_, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-12-08 14:49:49 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Chown(path string, uid int, gid int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_CHOWN32, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fchown(fd int, uid int, gid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := Syscall(SYS_FCHOWN32, uintptr(fd), uintptr(uid), uintptr(gid))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Fstat(fd int, stat *Stat_t) (err error) {
|
2010-09-07 07:23:49 -06:00
|
|
|
_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-10-06 17:39:38 -06:00
|
|
|
func Getegid() (egid int) {
|
2012-06-02 16:49:57 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETEGID32, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
egid = int(r0)
|
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-10-06 17:39:38 -06:00
|
|
|
func Geteuid() (euid int) {
|
2012-06-02 16:49:57 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETEUID32, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
euid = int(r0)
|
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-10-06 17:39:38 -06:00
|
|
|
func Getgid() (gid int) {
|
2012-06-02 16:49:57 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETGID32, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
gid = int(r0)
|
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2009-10-06 17:39:38 -06:00
|
|
|
func Getuid() (uid int) {
|
2012-06-02 16:49:57 -06:00
|
|
|
r0, _, _ := RawSyscall(SYS_GETUID32, 0, 0, 0)
|
2009-12-15 16:40:16 -07:00
|
|
|
uid = int(r0)
|
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Lchown(path string, uid int, gid int) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_LCHOWN32, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Listen(s int, n int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Lstat(path string, stat *Stat_t) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
2009-10-06 17:39:38 -06:00
|
|
|
|
2012-10-29 13:15:06 -06:00
|
|
|
func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
|
2011-05-20 12:51:31 -06:00
|
|
|
r0, _, e1 := Syscall6(SYS_SENDFILE64, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0)
|
|
|
|
written = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-05-20 12:51:31 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
r0, _, e1 := Syscall6(SYS__NEWSELECT, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
|
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-08-18 20:20:33 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setfsgid(gid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := Syscall(SYS_SETFSGID32, uintptr(gid), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setfsuid(uid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := Syscall(SYS_SETFSUID32, uintptr(uid), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setgid(gid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETGID32, uintptr(gid), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setregid(rgid int, egid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETREGID32, uintptr(rgid), uintptr(egid), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setresgid(rgid int, egid int, sgid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETRESGID32, uintptr(rgid), uintptr(egid), uintptr(sgid))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setresuid(ruid int, euid int, suid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETRESUID32, uintptr(ruid), uintptr(euid), uintptr(suid))
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Setreuid(ruid int, euid int) (err error) {
|
2012-06-02 16:49:57 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_SETREUID32, uintptr(ruid), uintptr(euid), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Shutdown(fd int, how int) (err error) {
|
2009-12-15 16:40:16 -07:00
|
|
|
_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) {
|
2011-01-05 12:35:07 -07:00
|
|
|
r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags))
|
|
|
|
n = int(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-01-05 12:35:07 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Stat(path string, stat *Stat_t) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2009-12-15 16:40:16 -07:00
|
|
|
return
|
2009-10-06 17:39:38 -06:00
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Gettimeofday(tv *Timeval) (err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2010-10-20 08:39:46 -06:00
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func Time(t *Time_t) (tt Time_t, err error) {
|
2011-03-16 20:03:01 -06:00
|
|
|
r0, _, e1 := RawSyscall(SYS_TIME, uintptr(unsafe.Pointer(t)), 0, 0)
|
2010-09-21 07:49:56 -06:00
|
|
|
tt = Time_t(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2010-09-21 07:49:56 -06:00
|
|
|
return
|
|
|
|
}
|
2011-04-06 15:52:02 -06:00
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
syscall: fix mkall.sh, mksyscall_linux.pl, and regen for Linux/ARM
CL 3075041 says ARM is not little-endian, but my test suggests otherwise.
My test program is:
package main
import ("fmt"; "syscall"; "os")
func main() {
err := syscall.Fallocate(1, 1/*FALLOC_FL_KEEP_SIZE*/, 0, int64(40960));
fmt.Fprintln(os.Stderr, err)
}
Without this CL, ./test > testfile will show: file too large; and strace shows:
fallocate(1, 01, 0, 175921860444160) = -1 EFBIG (File too large)
With this CL, ./test > testfile will show: <nil>; and strace shows:
fallocate(1, 01, 0, 40960) = 0
Quoting rsc:
"[It turns out that] ARM syscall ABI requires 64-bit arguments to use an
(even, odd) register pair, not an (odd, even) pair. Switching to "big-endian"
worked because it ended up using the high 32-bits (always zero in the tests
we had) as the padding word, because the 64-bit argument was the last one,
and because we fill in zeros for the rest of the system call arguments, up to
six. So it happened to work."
I updated mksyscall_linux.pl to accommodate the register pair ABI requirement,
and removed all hand-tweaked syscall routines in favor of the auto-generated
ones. These including: Ftruncate, Truncate, Pread and Pwrite.
Some recent Linux/ARM distributions do not bundle kernel asm headers,
so instead we always get latest asm/unistd.h from git.kernel.org (just like
what we do for FreeBSD).
R=ken, r, rsc, r, dave, iant
CC=golang-dev
https://golang.org/cl/5726051
2012-03-05 12:12:11 -07:00
|
|
|
func Pread(fd int, p []byte, offset int64) (n int, err error) {
|
|
|
|
var _p0 unsafe.Pointer
|
|
|
|
if len(p) > 0 {
|
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall6(SYS_PREAD64, 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 Pwrite(fd int, p []byte, offset int64) (n int, err error) {
|
|
|
|
var _p0 unsafe.Pointer
|
|
|
|
if len(p) > 0 {
|
|
|
|
_p0 = unsafe.Pointer(&p[0])
|
|
|
|
} else {
|
|
|
|
_p0 = unsafe.Pointer(&_zero)
|
|
|
|
}
|
|
|
|
r0, _, e1 := Syscall6(SYS_PWRITE64, 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 Truncate(path string, length int64) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
var _p0 *byte
|
|
|
|
_p0, err = BytePtrFromString(path)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, _, e1 := Syscall6(SYS_TRUNCATE64, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length), uintptr(length>>32), 0, 0)
|
syscall: fix mkall.sh, mksyscall_linux.pl, and regen for Linux/ARM
CL 3075041 says ARM is not little-endian, but my test suggests otherwise.
My test program is:
package main
import ("fmt"; "syscall"; "os")
func main() {
err := syscall.Fallocate(1, 1/*FALLOC_FL_KEEP_SIZE*/, 0, int64(40960));
fmt.Fprintln(os.Stderr, err)
}
Without this CL, ./test > testfile will show: file too large; and strace shows:
fallocate(1, 01, 0, 175921860444160) = -1 EFBIG (File too large)
With this CL, ./test > testfile will show: <nil>; and strace shows:
fallocate(1, 01, 0, 40960) = 0
Quoting rsc:
"[It turns out that] ARM syscall ABI requires 64-bit arguments to use an
(even, odd) register pair, not an (odd, even) pair. Switching to "big-endian"
worked because it ended up using the high 32-bits (always zero in the tests
we had) as the padding word, because the 64-bit argument was the last one,
and because we fill in zeros for the rest of the system call arguments, up to
six. So it happened to work."
I updated mksyscall_linux.pl to accommodate the register pair ABI requirement,
and removed all hand-tweaked syscall routines in favor of the auto-generated
ones. These including: Ftruncate, Truncate, Pread and Pwrite.
Some recent Linux/ARM distributions do not bundle kernel asm headers,
so instead we always get latest asm/unistd.h from git.kernel.org (just like
what we do for FreeBSD).
R=ken, r, rsc, r, dave, iant
CC=golang-dev
https://golang.org/cl/5726051
2012-03-05 12:12:11 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
|
|
|
func Ftruncate(fd int, length int64) (err error) {
|
|
|
|
_, _, e1 := Syscall6(SYS_FTRUNCATE64, uintptr(fd), 0, uintptr(length), uintptr(length>>32), 0, 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
2011-11-13 23:23:27 -07:00
|
|
|
func mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error) {
|
2011-04-06 15:52:02 -06:00
|
|
|
r0, _, e1 := Syscall6(SYS_MMAP2, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), uintptr(pageOffset))
|
|
|
|
xaddr = uintptr(r0)
|
2011-11-13 23:23:27 -07:00
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
2011-04-06 15:52:02 -06:00
|
|
|
return
|
|
|
|
}
|
2012-07-02 23:57:32 -06:00
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
|
|
|
func getrlimit(resource int, rlim *rlimit32) (err error) {
|
|
|
|
_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
|
|
|
|
|
|
|
|
func setrlimit(resource int, rlim *rlimit32) (err error) {
|
|
|
|
_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0)
|
|
|
|
if e1 != 0 {
|
|
|
|
err = e1
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|