← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/gabriel-samfira/sys/unix/syscall_linux_arm.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/gabriel-samfira/sys/unix/syscall_linux_arm.go
 
1
// Copyright 2009 The Go Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
// +build arm,linux
 
6
 
 
7
package unix
 
8
 
 
9
import (
 
10
        "syscall"
 
11
        "unsafe"
 
12
)
 
13
 
 
14
func Getpagesize() int { return 4096 }
 
15
 
 
16
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
 
17
 
 
18
func NsecToTimespec(nsec int64) (ts Timespec) {
 
19
        ts.Sec = int32(nsec / 1e9)
 
20
        ts.Nsec = int32(nsec % 1e9)
 
21
        return
 
22
}
 
23
 
 
24
func NsecToTimeval(nsec int64) (tv Timeval) {
 
25
        nsec += 999 // round up to microsecond
 
26
        tv.Sec = int32(nsec / 1e9)
 
27
        tv.Usec = int32(nsec % 1e9 / 1e3)
 
28
        return
 
29
}
 
30
 
 
31
func Pipe(p []int) (err error) {
 
32
        if len(p) != 2 {
 
33
                return EINVAL
 
34
        }
 
35
        var pp [2]_C_int
 
36
        err = pipe2(&pp, 0)
 
37
        p[0] = int(pp[0])
 
38
        p[1] = int(pp[1])
 
39
        return
 
40
}
 
41
 
 
42
//sysnb pipe2(p *[2]_C_int, flags int) (err error)
 
43
 
 
44
func Pipe2(p []int, flags int) (err error) {
 
45
        if len(p) != 2 {
 
46
                return EINVAL
 
47
        }
 
48
        var pp [2]_C_int
 
49
        err = pipe2(&pp, flags)
 
50
        p[0] = int(pp[0])
 
51
        p[1] = int(pp[1])
 
52
        return
 
53
}
 
54
 
 
55
// Underlying system call writes to newoffset via pointer.
 
56
// Implemented in assembly to avoid allocation.
 
57
func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno)
 
58
 
 
59
func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 
60
        newoffset, errno := seek(fd, offset, whence)
 
61
        if errno != 0 {
 
62
                return 0, errno
 
63
        }
 
64
        return newoffset, nil
 
65
}
 
66
 
 
67
//sys   accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error)
 
68
//sys   accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error)
 
69
//sys   bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
 
70
//sys   connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
 
71
//sysnb getgroups(n int, list *_Gid_t) (nn int, err error) = SYS_GETGROUPS32
 
72
//sysnb setgroups(n int, list *_Gid_t) (err error) = SYS_SETGROUPS32
 
73
//sys   getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
 
74
//sys   setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error)
 
75
//sysnb socket(domain int, typ int, proto int) (fd int, err error)
 
76
//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
 
77
//sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error)
 
78
//sys   recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error)
 
79
//sys   sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error)
 
80
//sysnb socketpair(domain int, typ int, flags int, fd *[2]int32) (err error)
 
81
//sys   recvmsg(s int, msg *Msghdr, flags int) (n int, err error)
 
82
//sys   sendmsg(s int, msg *Msghdr, flags int) (n int, err error)
 
83
 
 
84
// 64-bit file system and 32-bit uid calls
 
85
// (16-bit uid calls are not always supported in newer kernels)
 
86
//sys   Dup2(oldfd int, newfd int) (err error)
 
87
//sys   Fchown(fd int, uid int, gid int) (err error) = SYS_FCHOWN32
 
88
//sys   Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
 
89
//sysnb Getegid() (egid int) = SYS_GETEGID32
 
90
//sysnb Geteuid() (euid int) = SYS_GETEUID32
 
91
//sysnb Getgid() (gid int) = SYS_GETGID32
 
92
//sysnb Getuid() (uid int) = SYS_GETUID32
 
93
//sysnb InotifyInit() (fd int, err error)
 
94
//sys   Lchown(path string, uid int, gid int) (err error) = SYS_LCHOWN32
 
95
//sys   Listen(s int, n int) (err error)
 
96
//sys   Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
 
97
//sys   sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = SYS_SENDFILE64
 
98
//sys   Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) = SYS__NEWSELECT
 
99
//sys   Setfsgid(gid int) (err error) = SYS_SETFSGID32
 
100
//sys   Setfsuid(uid int) (err error) = SYS_SETFSUID32
 
101
//sysnb Setregid(rgid int, egid int) (err error) = SYS_SETREGID32
 
102
//sysnb Setresgid(rgid int, egid int, sgid int) (err error) = SYS_SETRESGID32
 
103
//sysnb Setresuid(ruid int, euid int, suid int) (err error) = SYS_SETRESUID32
 
104
//sysnb Setreuid(ruid int, euid int) (err error) = SYS_SETREUID32
 
105
//sys   Shutdown(fd int, how int) (err error)
 
106
//sys   Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
 
107
//sys   Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 
108
 
 
109
// Vsyscalls on amd64.
 
110
//sysnb Gettimeofday(tv *Timeval) (err error)
 
111
//sysnb Time(t *Time_t) (tt Time_t, err error)
 
112
 
 
113
//sys   Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
 
114
//sys   Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
 
115
//sys   Truncate(path string, length int64) (err error) = SYS_TRUNCATE64
 
116
//sys   Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64
 
117
 
 
118
func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 
119
        _, _, e1 := Syscall6(SYS_ARM_FADVISE64_64, uintptr(fd), uintptr(advice), uintptr(offset), uintptr(offset>>32), uintptr(length), uintptr(length>>32))
 
120
        if e1 != 0 {
 
121
                err = errnoErr(e1)
 
122
        }
 
123
        return
 
124
}
 
125
 
 
126
//sys   mmap2(addr uintptr, length uintptr, prot int, flags int, fd int, pageOffset uintptr) (xaddr uintptr, err error)
 
127
 
 
128
func Fstatfs(fd int, buf *Statfs_t) (err error) {
 
129
        _, _, e := Syscall(SYS_FSTATFS64, uintptr(fd), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
 
130
        if e != 0 {
 
131
                err = e
 
132
        }
 
133
        return
 
134
}
 
135
 
 
136
func Statfs(path string, buf *Statfs_t) (err error) {
 
137
        pathp, err := BytePtrFromString(path)
 
138
        if err != nil {
 
139
                return err
 
140
        }
 
141
        _, _, e := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(pathp)), unsafe.Sizeof(*buf), uintptr(unsafe.Pointer(buf)))
 
142
        if e != 0 {
 
143
                err = e
 
144
        }
 
145
        return
 
146
}
 
147
 
 
148
func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) {
 
149
        page := uintptr(offset / 4096)
 
150
        if offset != int64(page)*4096 {
 
151
                return 0, EINVAL
 
152
        }
 
153
        return mmap2(addr, length, prot, flags, fd, page)
 
154
}
 
155
 
 
156
type rlimit32 struct {
 
157
        Cur uint32
 
158
        Max uint32
 
159
}
 
160
 
 
161
//sysnb getrlimit(resource int, rlim *rlimit32) (err error) = SYS_GETRLIMIT
 
162
 
 
163
const rlimInf32 = ^uint32(0)
 
164
const rlimInf64 = ^uint64(0)
 
165
 
 
166
func Getrlimit(resource int, rlim *Rlimit) (err error) {
 
167
        err = prlimit(0, resource, nil, rlim)
 
168
        if err != ENOSYS {
 
169
                return err
 
170
        }
 
171
 
 
172
        rl := rlimit32{}
 
173
        err = getrlimit(resource, &rl)
 
174
        if err != nil {
 
175
                return
 
176
        }
 
177
 
 
178
        if rl.Cur == rlimInf32 {
 
179
                rlim.Cur = rlimInf64
 
180
        } else {
 
181
                rlim.Cur = uint64(rl.Cur)
 
182
        }
 
183
 
 
184
        if rl.Max == rlimInf32 {
 
185
                rlim.Max = rlimInf64
 
186
        } else {
 
187
                rlim.Max = uint64(rl.Max)
 
188
        }
 
189
        return
 
190
}
 
191
 
 
192
//sysnb setrlimit(resource int, rlim *rlimit32) (err error) = SYS_SETRLIMIT
 
193
 
 
194
func Setrlimit(resource int, rlim *Rlimit) (err error) {
 
195
        err = prlimit(0, resource, rlim, nil)
 
196
        if err != ENOSYS {
 
197
                return err
 
198
        }
 
199
 
 
200
        rl := rlimit32{}
 
201
        if rlim.Cur == rlimInf64 {
 
202
                rl.Cur = rlimInf32
 
203
        } else if rlim.Cur < uint64(rlimInf32) {
 
204
                rl.Cur = uint32(rlim.Cur)
 
205
        } else {
 
206
                return EINVAL
 
207
        }
 
208
        if rlim.Max == rlimInf64 {
 
209
                rl.Max = rlimInf32
 
210
        } else if rlim.Max < uint64(rlimInf32) {
 
211
                rl.Max = uint32(rlim.Max)
 
212
        } else {
 
213
                return EINVAL
 
214
        }
 
215
 
 
216
        return setrlimit(resource, &rl)
 
217
}
 
218
 
 
219
func (r *PtraceRegs) PC() uint64 { return uint64(r.Uregs[15]) }
 
220
 
 
221
func (r *PtraceRegs) SetPC(pc uint64) { r.Uregs[15] = uint32(pc) }
 
222
 
 
223
func (iov *Iovec) SetLen(length int) {
 
224
        iov.Len = uint32(length)
 
225
}
 
226
 
 
227
func (msghdr *Msghdr) SetControllen(length int) {
 
228
        msghdr.Controllen = uint32(length)
 
229
}
 
230
 
 
231
func (cmsg *Cmsghdr) SetLen(length int) {
 
232
        cmsg.Len = uint32(length)
 
233
}