diff options
Diffstat (limited to 'vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_solaris.go')
-rw-r--r-- | vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_solaris.go | 713 |
1 files changed, 713 insertions, 0 deletions
diff --git a/vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_solaris.go b/vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_solaris.go new file mode 100644 index 0000000..0083732 --- /dev/null +++ b/vendor/github.com/fsouza/go-dockerclient/external/golang.org/x/sys/unix/syscall_solaris.go | |||
@@ -0,0 +1,713 @@ | |||
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 | // Solaris system calls. | ||
6 | // This file is compiled as ordinary Go code, | ||
7 | // but it is also input to mksyscall, | ||
8 | // which parses the //sys lines and generates system call stubs. | ||
9 | // Note that sometimes we use a lowercase //sys name and wrap | ||
10 | // it in our own nicer implementation, either here or in | ||
11 | // syscall_solaris.go or syscall_unix.go. | ||
12 | |||
13 | package unix | ||
14 | |||
15 | import ( | ||
16 | "sync/atomic" | ||
17 | "syscall" | ||
18 | "unsafe" | ||
19 | ) | ||
20 | |||
21 | // Implemented in runtime/syscall_solaris.go. | ||
22 | type syscallFunc uintptr | ||
23 | |||
24 | func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) | ||
25 | func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) | ||
26 | |||
27 | type SockaddrDatalink struct { | ||
28 | Family uint16 | ||
29 | Index uint16 | ||
30 | Type uint8 | ||
31 | Nlen uint8 | ||
32 | Alen uint8 | ||
33 | Slen uint8 | ||
34 | Data [244]int8 | ||
35 | raw RawSockaddrDatalink | ||
36 | } | ||
37 | |||
38 | func clen(n []byte) int { | ||
39 | for i := 0; i < len(n); i++ { | ||
40 | if n[i] == 0 { | ||
41 | return i | ||
42 | } | ||
43 | } | ||
44 | return len(n) | ||
45 | } | ||
46 | |||
47 | // ParseDirent parses up to max directory entries in buf, | ||
48 | // appending the names to names. It returns the number | ||
49 | // bytes consumed from buf, the number of entries added | ||
50 | // to names, and the new names slice. | ||
51 | func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) { | ||
52 | origlen := len(buf) | ||
53 | for max != 0 && len(buf) > 0 { | ||
54 | dirent := (*Dirent)(unsafe.Pointer(&buf[0])) | ||
55 | if dirent.Reclen == 0 { | ||
56 | buf = nil | ||
57 | break | ||
58 | } | ||
59 | buf = buf[dirent.Reclen:] | ||
60 | if dirent.Ino == 0 { // File absent in directory. | ||
61 | continue | ||
62 | } | ||
63 | bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0])) | ||
64 | var name = string(bytes[0:clen(bytes[:])]) | ||
65 | if name == "." || name == ".." { // Useless names | ||
66 | continue | ||
67 | } | ||
68 | max-- | ||
69 | count++ | ||
70 | names = append(names, name) | ||
71 | } | ||
72 | return origlen - len(buf), count, names | ||
73 | } | ||
74 | |||
75 | func pipe() (r uintptr, w uintptr, err uintptr) | ||
76 | |||
77 | func Pipe(p []int) (err error) { | ||
78 | if len(p) != 2 { | ||
79 | return EINVAL | ||
80 | } | ||
81 | r0, w0, e1 := pipe() | ||
82 | if e1 != 0 { | ||
83 | err = syscall.Errno(e1) | ||
84 | } | ||
85 | p[0], p[1] = int(r0), int(w0) | ||
86 | return | ||
87 | } | ||
88 | |||
89 | func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
90 | if sa.Port < 0 || sa.Port > 0xFFFF { | ||
91 | return nil, 0, EINVAL | ||
92 | } | ||
93 | sa.raw.Family = AF_INET | ||
94 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | ||
95 | p[0] = byte(sa.Port >> 8) | ||
96 | p[1] = byte(sa.Port) | ||
97 | for i := 0; i < len(sa.Addr); i++ { | ||
98 | sa.raw.Addr[i] = sa.Addr[i] | ||
99 | } | ||
100 | return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil | ||
101 | } | ||
102 | |||
103 | func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
104 | if sa.Port < 0 || sa.Port > 0xFFFF { | ||
105 | return nil, 0, EINVAL | ||
106 | } | ||
107 | sa.raw.Family = AF_INET6 | ||
108 | p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) | ||
109 | p[0] = byte(sa.Port >> 8) | ||
110 | p[1] = byte(sa.Port) | ||
111 | sa.raw.Scope_id = sa.ZoneId | ||
112 | for i := 0; i < len(sa.Addr); i++ { | ||
113 | sa.raw.Addr[i] = sa.Addr[i] | ||
114 | } | ||
115 | return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil | ||
116 | } | ||
117 | |||
118 | func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { | ||
119 | name := sa.Name | ||
120 | n := len(name) | ||
121 | if n >= len(sa.raw.Path) { | ||
122 | return nil, 0, EINVAL | ||
123 | } | ||
124 | sa.raw.Family = AF_UNIX | ||
125 | for i := 0; i < n; i++ { | ||
126 | sa.raw.Path[i] = int8(name[i]) | ||
127 | } | ||
128 | // length is family (uint16), name, NUL. | ||
129 | sl := _Socklen(2) | ||
130 | if n > 0 { | ||
131 | sl += _Socklen(n) + 1 | ||
132 | } | ||
133 | if sa.raw.Path[0] == '@' { | ||
134 | sa.raw.Path[0] = 0 | ||
135 | // Don't count trailing NUL for abstract address. | ||
136 | sl-- | ||
137 | } | ||
138 | |||
139 | return unsafe.Pointer(&sa.raw), sl, nil | ||
140 | } | ||
141 | |||
142 | //sys getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getsockname | ||
143 | |||
144 | func Getsockname(fd int) (sa Sockaddr, err error) { | ||
145 | var rsa RawSockaddrAny | ||
146 | var len _Socklen = SizeofSockaddrAny | ||
147 | if err = getsockname(fd, &rsa, &len); err != nil { | ||
148 | return | ||
149 | } | ||
150 | return anyToSockaddr(&rsa) | ||
151 | } | ||
152 | |||
153 | const ImplementsGetwd = true | ||
154 | |||
155 | //sys Getcwd(buf []byte) (n int, err error) | ||
156 | |||
157 | func Getwd() (wd string, err error) { | ||
158 | var buf [PathMax]byte | ||
159 | // Getcwd will return an error if it failed for any reason. | ||
160 | _, err = Getcwd(buf[0:]) | ||
161 | if err != nil { | ||
162 | return "", err | ||
163 | } | ||
164 | n := clen(buf[:]) | ||
165 | if n < 1 { | ||
166 | return "", EINVAL | ||
167 | } | ||
168 | return string(buf[:n]), nil | ||
169 | } | ||
170 | |||
171 | /* | ||
172 | * Wrapped | ||
173 | */ | ||
174 | |||
175 | //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error) | ||
176 | //sysnb setgroups(ngid int, gid *_Gid_t) (err error) | ||
177 | |||
178 | func Getgroups() (gids []int, err error) { | ||
179 | n, err := getgroups(0, nil) | ||
180 | // Check for error and sanity check group count. Newer versions of | ||
181 | // Solaris allow up to 1024 (NGROUPS_MAX). | ||
182 | if n < 0 || n > 1024 { | ||
183 | if err != nil { | ||
184 | return nil, err | ||
185 | } | ||
186 | return nil, EINVAL | ||
187 | } else if n == 0 { | ||
188 | return nil, nil | ||
189 | } | ||
190 | |||
191 | a := make([]_Gid_t, n) | ||
192 | n, err = getgroups(n, &a[0]) | ||
193 | if n == -1 { | ||
194 | return nil, err | ||
195 | } | ||
196 | gids = make([]int, n) | ||
197 | for i, v := range a[0:n] { | ||
198 | gids[i] = int(v) | ||
199 | } | ||
200 | return | ||
201 | } | ||
202 | |||
203 | func Setgroups(gids []int) (err error) { | ||
204 | if len(gids) == 0 { | ||
205 | return setgroups(0, nil) | ||
206 | } | ||
207 | |||
208 | a := make([]_Gid_t, len(gids)) | ||
209 | for i, v := range gids { | ||
210 | a[i] = _Gid_t(v) | ||
211 | } | ||
212 | return setgroups(len(a), &a[0]) | ||
213 | } | ||
214 | |||
215 | func ReadDirent(fd int, buf []byte) (n int, err error) { | ||
216 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. | ||
217 | // TODO(rsc): Can we use a single global basep for all calls? | ||
218 | return Getdents(fd, buf, new(uintptr)) | ||
219 | } | ||
220 | |||
221 | // Wait status is 7 bits at bottom, either 0 (exited), | ||
222 | // 0x7F (stopped), or a signal number that caused an exit. | ||
223 | // The 0x80 bit is whether there was a core dump. | ||
224 | // An extra number (exit code, signal causing a stop) | ||
225 | // is in the high bits. | ||
226 | |||
227 | type WaitStatus uint32 | ||
228 | |||
229 | const ( | ||
230 | mask = 0x7F | ||
231 | core = 0x80 | ||
232 | shift = 8 | ||
233 | |||
234 | exited = 0 | ||
235 | stopped = 0x7F | ||
236 | ) | ||
237 | |||
238 | func (w WaitStatus) Exited() bool { return w&mask == exited } | ||
239 | |||
240 | func (w WaitStatus) ExitStatus() int { | ||
241 | if w&mask != exited { | ||
242 | return -1 | ||
243 | } | ||
244 | return int(w >> shift) | ||
245 | } | ||
246 | |||
247 | func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 } | ||
248 | |||
249 | func (w WaitStatus) Signal() syscall.Signal { | ||
250 | sig := syscall.Signal(w & mask) | ||
251 | if sig == stopped || sig == 0 { | ||
252 | return -1 | ||
253 | } | ||
254 | return sig | ||
255 | } | ||
256 | |||
257 | func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } | ||
258 | |||
259 | func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP } | ||
260 | |||
261 | func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP } | ||
262 | |||
263 | func (w WaitStatus) StopSignal() syscall.Signal { | ||
264 | if !w.Stopped() { | ||
265 | return -1 | ||
266 | } | ||
267 | return syscall.Signal(w>>shift) & 0xFF | ||
268 | } | ||
269 | |||
270 | func (w WaitStatus) TrapCause() int { return -1 } | ||
271 | |||
272 | func wait4(pid uintptr, wstatus *WaitStatus, options uintptr, rusage *Rusage) (wpid uintptr, err uintptr) | ||
273 | |||
274 | func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { | ||
275 | r0, e1 := wait4(uintptr(pid), wstatus, uintptr(options), rusage) | ||
276 | if e1 != 0 { | ||
277 | err = syscall.Errno(e1) | ||
278 | } | ||
279 | return int(r0), err | ||
280 | } | ||
281 | |||
282 | func gethostname() (name string, err uintptr) | ||
283 | |||
284 | func Gethostname() (name string, err error) { | ||
285 | name, e1 := gethostname() | ||
286 | if e1 != 0 { | ||
287 | err = syscall.Errno(e1) | ||
288 | } | ||
289 | return name, err | ||
290 | } | ||
291 | |||
292 | //sys utimes(path string, times *[2]Timeval) (err error) | ||
293 | |||
294 | func Utimes(path string, tv []Timeval) (err error) { | ||
295 | if tv == nil { | ||
296 | return utimes(path, nil) | ||
297 | } | ||
298 | if len(tv) != 2 { | ||
299 | return EINVAL | ||
300 | } | ||
301 | return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
302 | } | ||
303 | |||
304 | //sys utimensat(fd int, path string, times *[2]Timespec, flag int) (err error) | ||
305 | |||
306 | func UtimesNano(path string, ts []Timespec) error { | ||
307 | if ts == nil { | ||
308 | return utimensat(AT_FDCWD, path, nil, 0) | ||
309 | } | ||
310 | if len(ts) != 2 { | ||
311 | return EINVAL | ||
312 | } | ||
313 | return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) | ||
314 | } | ||
315 | |||
316 | func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { | ||
317 | if ts == nil { | ||
318 | return utimensat(dirfd, path, nil, flags) | ||
319 | } | ||
320 | if len(ts) != 2 { | ||
321 | return EINVAL | ||
322 | } | ||
323 | return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) | ||
324 | } | ||
325 | |||
326 | //sys fcntl(fd int, cmd int, arg int) (val int, err error) | ||
327 | |||
328 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. | ||
329 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { | ||
330 | _, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0) | ||
331 | if e1 != 0 { | ||
332 | return e1 | ||
333 | } | ||
334 | return nil | ||
335 | } | ||
336 | |||
337 | //sys futimesat(fildes int, path *byte, times *[2]Timeval) (err error) | ||
338 | |||
339 | func Futimesat(dirfd int, path string, tv []Timeval) error { | ||
340 | pathp, err := BytePtrFromString(path) | ||
341 | if err != nil { | ||
342 | return err | ||
343 | } | ||
344 | if tv == nil { | ||
345 | return futimesat(dirfd, pathp, nil) | ||
346 | } | ||
347 | if len(tv) != 2 { | ||
348 | return EINVAL | ||
349 | } | ||
350 | return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
351 | } | ||
352 | |||
353 | // Solaris doesn't have an futimes function because it allows NULL to be | ||
354 | // specified as the path for futimesat. However, Go doesn't like | ||
355 | // NULL-style string interfaces, so this simple wrapper is provided. | ||
356 | func Futimes(fd int, tv []Timeval) error { | ||
357 | if tv == nil { | ||
358 | return futimesat(fd, nil, nil) | ||
359 | } | ||
360 | if len(tv) != 2 { | ||
361 | return EINVAL | ||
362 | } | ||
363 | return futimesat(fd, nil, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) | ||
364 | } | ||
365 | |||
366 | func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, error) { | ||
367 | switch rsa.Addr.Family { | ||
368 | case AF_UNIX: | ||
369 | pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) | ||
370 | sa := new(SockaddrUnix) | ||
371 | // Assume path ends at NUL. | ||
372 | // This is not technically the Solaris semantics for | ||
373 | // abstract Unix domain sockets -- they are supposed | ||
374 | // to be uninterpreted fixed-size binary blobs -- but | ||
375 | // everyone uses this convention. | ||
376 | n := 0 | ||
377 | for n < len(pp.Path) && pp.Path[n] != 0 { | ||
378 | n++ | ||
379 | } | ||
380 | bytes := (*[10000]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] | ||
381 | sa.Name = string(bytes) | ||
382 | return sa, nil | ||
383 | |||
384 | case AF_INET: | ||
385 | pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) | ||
386 | sa := new(SockaddrInet4) | ||
387 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | ||
388 | sa.Port = int(p[0])<<8 + int(p[1]) | ||
389 | for i := 0; i < len(sa.Addr); i++ { | ||
390 | sa.Addr[i] = pp.Addr[i] | ||
391 | } | ||
392 | return sa, nil | ||
393 | |||
394 | case AF_INET6: | ||
395 | pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) | ||
396 | sa := new(SockaddrInet6) | ||
397 | p := (*[2]byte)(unsafe.Pointer(&pp.Port)) | ||
398 | sa.Port = int(p[0])<<8 + int(p[1]) | ||
399 | sa.ZoneId = pp.Scope_id | ||
400 | for i := 0; i < len(sa.Addr); i++ { | ||
401 | sa.Addr[i] = pp.Addr[i] | ||
402 | } | ||
403 | return sa, nil | ||
404 | } | ||
405 | return nil, EAFNOSUPPORT | ||
406 | } | ||
407 | |||
408 | //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = libsocket.accept | ||
409 | |||
410 | func Accept(fd int) (nfd int, sa Sockaddr, err error) { | ||
411 | var rsa RawSockaddrAny | ||
412 | var len _Socklen = SizeofSockaddrAny | ||
413 | nfd, err = accept(fd, &rsa, &len) | ||
414 | if nfd == -1 { | ||
415 | return | ||
416 | } | ||
417 | sa, err = anyToSockaddr(&rsa) | ||
418 | if err != nil { | ||
419 | Close(nfd) | ||
420 | nfd = 0 | ||
421 | } | ||
422 | return | ||
423 | } | ||
424 | |||
425 | //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.recvmsg | ||
426 | |||
427 | func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { | ||
428 | var msg Msghdr | ||
429 | var rsa RawSockaddrAny | ||
430 | msg.Name = (*byte)(unsafe.Pointer(&rsa)) | ||
431 | msg.Namelen = uint32(SizeofSockaddrAny) | ||
432 | var iov Iovec | ||
433 | if len(p) > 0 { | ||
434 | iov.Base = (*int8)(unsafe.Pointer(&p[0])) | ||
435 | iov.SetLen(len(p)) | ||
436 | } | ||
437 | var dummy int8 | ||
438 | if len(oob) > 0 { | ||
439 | // receive at least one normal byte | ||
440 | if len(p) == 0 { | ||
441 | iov.Base = &dummy | ||
442 | iov.SetLen(1) | ||
443 | } | ||
444 | msg.Accrights = (*int8)(unsafe.Pointer(&oob[0])) | ||
445 | } | ||
446 | msg.Iov = &iov | ||
447 | msg.Iovlen = 1 | ||
448 | if n, err = recvmsg(fd, &msg, flags); n == -1 { | ||
449 | return | ||
450 | } | ||
451 | oobn = int(msg.Accrightslen) | ||
452 | // source address is only specified if the socket is unconnected | ||
453 | if rsa.Addr.Family != AF_UNSPEC { | ||
454 | from, err = anyToSockaddr(&rsa) | ||
455 | } | ||
456 | return | ||
457 | } | ||
458 | |||
459 | func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { | ||
460 | _, err = SendmsgN(fd, p, oob, to, flags) | ||
461 | return | ||
462 | } | ||
463 | |||
464 | //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.sendmsg | ||
465 | |||
466 | func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { | ||
467 | var ptr unsafe.Pointer | ||
468 | var salen _Socklen | ||
469 | if to != nil { | ||
470 | ptr, salen, err = to.sockaddr() | ||
471 | if err != nil { | ||
472 | return 0, err | ||
473 | } | ||
474 | } | ||
475 | var msg Msghdr | ||
476 | msg.Name = (*byte)(unsafe.Pointer(ptr)) | ||
477 | msg.Namelen = uint32(salen) | ||
478 | var iov Iovec | ||
479 | if len(p) > 0 { | ||
480 | iov.Base = (*int8)(unsafe.Pointer(&p[0])) | ||
481 | iov.SetLen(len(p)) | ||
482 | } | ||
483 | var dummy int8 | ||
484 | if len(oob) > 0 { | ||
485 | // send at least one normal byte | ||
486 | if len(p) == 0 { | ||
487 | iov.Base = &dummy | ||
488 | iov.SetLen(1) | ||
489 | } | ||
490 | msg.Accrights = (*int8)(unsafe.Pointer(&oob[0])) | ||
491 | } | ||
492 | msg.Iov = &iov | ||
493 | msg.Iovlen = 1 | ||
494 | if n, err = sendmsg(fd, &msg, flags); err != nil { | ||
495 | return 0, err | ||
496 | } | ||
497 | if len(oob) > 0 && len(p) == 0 { | ||
498 | n = 0 | ||
499 | } | ||
500 | return n, nil | ||
501 | } | ||
502 | |||
503 | //sys acct(path *byte) (err error) | ||
504 | |||
505 | func Acct(path string) (err error) { | ||
506 | if len(path) == 0 { | ||
507 | // Assume caller wants to disable accounting. | ||
508 | return acct(nil) | ||
509 | } | ||
510 | |||
511 | pathp, err := BytePtrFromString(path) | ||
512 | if err != nil { | ||
513 | return err | ||
514 | } | ||
515 | return acct(pathp) | ||
516 | } | ||
517 | |||
518 | /* | ||
519 | * Expose the ioctl function | ||
520 | */ | ||
521 | |||
522 | //sys ioctl(fd int, req int, arg uintptr) (err error) | ||
523 | |||
524 | func IoctlSetInt(fd int, req int, value int) (err error) { | ||
525 | return ioctl(fd, req, uintptr(value)) | ||
526 | } | ||
527 | |||
528 | func IoctlSetWinsize(fd int, req int, value *Winsize) (err error) { | ||
529 | return ioctl(fd, req, uintptr(unsafe.Pointer(value))) | ||
530 | } | ||
531 | |||
532 | func IoctlSetTermios(fd int, req int, value *Termios) (err error) { | ||
533 | return ioctl(fd, req, uintptr(unsafe.Pointer(value))) | ||
534 | } | ||
535 | |||
536 | func IoctlSetTermio(fd int, req int, value *Termio) (err error) { | ||
537 | return ioctl(fd, req, uintptr(unsafe.Pointer(value))) | ||
538 | } | ||
539 | |||
540 | func IoctlGetInt(fd int, req int) (int, error) { | ||
541 | var value int | ||
542 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
543 | return value, err | ||
544 | } | ||
545 | |||
546 | func IoctlGetWinsize(fd int, req int) (*Winsize, error) { | ||
547 | var value Winsize | ||
548 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
549 | return &value, err | ||
550 | } | ||
551 | |||
552 | func IoctlGetTermios(fd int, req int) (*Termios, error) { | ||
553 | var value Termios | ||
554 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
555 | return &value, err | ||
556 | } | ||
557 | |||
558 | func IoctlGetTermio(fd int, req int) (*Termio, error) { | ||
559 | var value Termio | ||
560 | err := ioctl(fd, req, uintptr(unsafe.Pointer(&value))) | ||
561 | return &value, err | ||
562 | } | ||
563 | |||
564 | /* | ||
565 | * Exposed directly | ||
566 | */ | ||
567 | //sys Access(path string, mode uint32) (err error) | ||
568 | //sys Adjtime(delta *Timeval, olddelta *Timeval) (err error) | ||
569 | //sys Chdir(path string) (err error) | ||
570 | //sys Chmod(path string, mode uint32) (err error) | ||
571 | //sys Chown(path string, uid int, gid int) (err error) | ||
572 | //sys Chroot(path string) (err error) | ||
573 | //sys Close(fd int) (err error) | ||
574 | //sys Creat(path string, mode uint32) (fd int, err error) | ||
575 | //sys Dup(fd int) (nfd int, err error) | ||
576 | //sys Dup2(oldfd int, newfd int) (err error) | ||
577 | //sys Exit(code int) | ||
578 | //sys Fchdir(fd int) (err error) | ||
579 | //sys Fchmod(fd int, mode uint32) (err error) | ||
580 | //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) | ||
581 | //sys Fchown(fd int, uid int, gid int) (err error) | ||
582 | //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) | ||
583 | //sys Fdatasync(fd int) (err error) | ||
584 | //sys Fpathconf(fd int, name int) (val int, err error) | ||
585 | //sys Fstat(fd int, stat *Stat_t) (err error) | ||
586 | //sys Getdents(fd int, buf []byte, basep *uintptr) (n int, err error) | ||
587 | //sysnb Getgid() (gid int) | ||
588 | //sysnb Getpid() (pid int) | ||
589 | //sysnb Getpgid(pid int) (pgid int, err error) | ||
590 | //sysnb Getpgrp() (pgid int, err error) | ||
591 | //sys Geteuid() (euid int) | ||
592 | //sys Getegid() (egid int) | ||
593 | //sys Getppid() (ppid int) | ||
594 | //sys Getpriority(which int, who int) (n int, err error) | ||
595 | //sysnb Getrlimit(which int, lim *Rlimit) (err error) | ||
596 | //sysnb Getrusage(who int, rusage *Rusage) (err error) | ||
597 | //sysnb Gettimeofday(tv *Timeval) (err error) | ||
598 | //sysnb Getuid() (uid int) | ||
599 | //sys Kill(pid int, signum syscall.Signal) (err error) | ||
600 | //sys Lchown(path string, uid int, gid int) (err error) | ||
601 | //sys Link(path string, link string) (err error) | ||
602 | //sys Listen(s int, backlog int) (err error) = libsocket.listen | ||
603 | //sys Lstat(path string, stat *Stat_t) (err error) | ||
604 | //sys Madvise(b []byte, advice int) (err error) | ||
605 | //sys Mkdir(path string, mode uint32) (err error) | ||
606 | //sys Mkdirat(dirfd int, path string, mode uint32) (err error) | ||
607 | //sys Mkfifo(path string, mode uint32) (err error) | ||
608 | //sys Mkfifoat(dirfd int, path string, mode uint32) (err error) | ||
609 | //sys Mknod(path string, mode uint32, dev int) (err error) | ||
610 | //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) | ||
611 | //sys Mlock(b []byte) (err error) | ||
612 | //sys Mlockall(flags int) (err error) | ||
613 | //sys Mprotect(b []byte, prot int) (err error) | ||
614 | //sys Munlock(b []byte) (err error) | ||
615 | //sys Munlockall() (err error) | ||
616 | //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) | ||
617 | //sys Open(path string, mode int, perm uint32) (fd int, err error) | ||
618 | //sys Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) | ||
619 | //sys Pathconf(path string, name int) (val int, err error) | ||
620 | //sys Pause() (err error) | ||
621 | //sys Pread(fd int, p []byte, offset int64) (n int, err error) | ||
622 | //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) | ||
623 | //sys read(fd int, p []byte) (n int, err error) | ||
624 | //sys Readlink(path string, buf []byte) (n int, err error) | ||
625 | //sys Rename(from string, to string) (err error) | ||
626 | //sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) | ||
627 | //sys Rmdir(path string) (err error) | ||
628 | //sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek | ||
629 | //sysnb Setegid(egid int) (err error) | ||
630 | //sysnb Seteuid(euid int) (err error) | ||
631 | //sysnb Setgid(gid int) (err error) | ||
632 | //sys Sethostname(p []byte) (err error) | ||
633 | //sysnb Setpgid(pid int, pgid int) (err error) | ||
634 | //sys Setpriority(which int, who int, prio int) (err error) | ||
635 | //sysnb Setregid(rgid int, egid int) (err error) | ||
636 | //sysnb Setreuid(ruid int, euid int) (err error) | ||
637 | //sysnb Setrlimit(which int, lim *Rlimit) (err error) | ||
638 | //sysnb Setsid() (pid int, err error) | ||
639 | //sysnb Setuid(uid int) (err error) | ||
640 | //sys Shutdown(s int, how int) (err error) = libsocket.shutdown | ||
641 | //sys Stat(path string, stat *Stat_t) (err error) | ||
642 | //sys Symlink(path string, link string) (err error) | ||
643 | //sys Sync() (err error) | ||
644 | //sysnb Times(tms *Tms) (ticks uintptr, err error) | ||
645 | //sys Truncate(path string, length int64) (err error) | ||
646 | //sys Fsync(fd int) (err error) | ||
647 | //sys Ftruncate(fd int, length int64) (err error) | ||
648 | //sys Umask(mask int) (oldmask int) | ||
649 | //sysnb Uname(buf *Utsname) (err error) | ||
650 | //sys Unmount(target string, flags int) (err error) = libc.umount | ||
651 | //sys Unlink(path string) (err error) | ||
652 | //sys Unlinkat(dirfd int, path string) (err error) | ||
653 | //sys Ustat(dev int, ubuf *Ustat_t) (err error) | ||
654 | //sys Utime(path string, buf *Utimbuf) (err error) | ||
655 | //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.bind | ||
656 | //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.connect | ||
657 | //sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) | ||
658 | //sys munmap(addr uintptr, length uintptr) (err error) | ||
659 | //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.sendto | ||
660 | //sys socket(domain int, typ int, proto int) (fd int, err error) = libsocket.socket | ||
661 | //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) = libsocket.socketpair | ||
662 | //sys write(fd int, p []byte) (n int, err error) | ||
663 | //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) = libsocket.getsockopt | ||
664 | //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getpeername | ||
665 | //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) = libsocket.setsockopt | ||
666 | //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = libsocket.recvfrom | ||
667 | |||
668 | func readlen(fd int, buf *byte, nbuf int) (n int, err error) { | ||
669 | r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procread)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0) | ||
670 | n = int(r0) | ||
671 | if e1 != 0 { | ||
672 | err = e1 | ||
673 | } | ||
674 | return | ||
675 | } | ||
676 | |||
677 | func writelen(fd int, buf *byte, nbuf int) (n int, err error) { | ||
678 | r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procwrite)), 3, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf), 0, 0, 0) | ||
679 | n = int(r0) | ||
680 | if e1 != 0 { | ||
681 | err = e1 | ||
682 | } | ||
683 | return | ||
684 | } | ||
685 | |||
686 | var mapper = &mmapper{ | ||
687 | active: make(map[*byte][]byte), | ||
688 | mmap: mmap, | ||
689 | munmap: munmap, | ||
690 | } | ||
691 | |||
692 | func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { | ||
693 | return mapper.Mmap(fd, offset, length, prot, flags) | ||
694 | } | ||
695 | |||
696 | func Munmap(b []byte) (err error) { | ||
697 | return mapper.Munmap(b) | ||
698 | } | ||
699 | |||
700 | //sys sysconf(name int) (n int64, err error) | ||
701 | |||
702 | // pageSize caches the value of Getpagesize, since it can't change | ||
703 | // once the system is booted. | ||
704 | var pageSize int64 // accessed atomically | ||
705 | |||
706 | func Getpagesize() int { | ||
707 | n := atomic.LoadInt64(&pageSize) | ||
708 | if n == 0 { | ||
709 | n, _ = sysconf(_SC_PAGESIZE) | ||
710 | atomic.StoreInt64(&pageSize, n) | ||
711 | } | ||
712 | return int(n) | ||
713 | } | ||