]>
Commit | Line | Data |
---|---|---|
9b12e4fe JC |
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 | } |