syscall_solaris.go raw
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 "fmt"
17 "os"
18 "runtime"
19 "sync"
20 "syscall"
21 "unsafe"
22 )
23
24 // Implemented in runtime/syscall_solaris.go.
25 type syscallFunc uintptr
26
27 func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
28 func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
29
30 // SockaddrDatalink implements the Sockaddr interface for AF_LINK type sockets.
31 type SockaddrDatalink struct {
32 Family uint16
33 Index uint16
34 Type uint8
35 Nlen uint8
36 Alen uint8
37 Slen uint8
38 Data [244]int8
39 raw RawSockaddrDatalink
40 }
41
42 func direntIno(buf []byte) (uint64, bool) {
43 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
44 }
45
46 func direntReclen(buf []byte) (uint64, bool) {
47 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
48 }
49
50 func direntNamlen(buf []byte) (uint64, bool) {
51 reclen, ok := direntReclen(buf)
52 if !ok {
53 return 0, false
54 }
55 return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
56 }
57
58 //sysnb pipe(p *[2]_C_int) (n int, err error)
59
60 func Pipe(p []int) (err error) {
61 if len(p) != 2 {
62 return EINVAL
63 }
64 var pp [2]_C_int
65 n, err := pipe(&pp)
66 if n != 0 {
67 return err
68 }
69 if err == nil {
70 p[0] = int(pp[0])
71 p[1] = int(pp[1])
72 }
73 return nil
74 }
75
76 //sysnb pipe2(p *[2]_C_int, flags int) (err error)
77
78 func Pipe2(p []int, flags int) error {
79 if len(p) != 2 {
80 return EINVAL
81 }
82 var pp [2]_C_int
83 err := pipe2(&pp, flags)
84 if err == nil {
85 p[0] = int(pp[0])
86 p[1] = int(pp[1])
87 }
88 return err
89 }
90
91 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
92 if sa.Port < 0 || sa.Port > 0xFFFF {
93 return nil, 0, EINVAL
94 }
95 sa.raw.Family = AF_INET
96 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
97 p[0] = byte(sa.Port >> 8)
98 p[1] = byte(sa.Port)
99 sa.raw.Addr = sa.Addr
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 sa.raw.Addr = sa.Addr
113 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
114 }
115
116 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
117 name := sa.Name
118 n := len(name)
119 if n >= len(sa.raw.Path) {
120 return nil, 0, EINVAL
121 }
122 sa.raw.Family = AF_UNIX
123 for i := 0; i < n; i++ {
124 sa.raw.Path[i] = int8(name[i])
125 }
126 // length is family (uint16), name, NUL.
127 sl := _Socklen(2)
128 if n > 0 {
129 sl += _Socklen(n) + 1
130 }
131 if sa.raw.Path[0] == '@' || (sa.raw.Path[0] == 0 && sl > 3) {
132 // Check sl > 3 so we don't change unnamed socket behavior.
133 sa.raw.Path[0] = 0
134 // Don't count trailing NUL for abstract address.
135 sl--
136 }
137
138 return unsafe.Pointer(&sa.raw), sl, nil
139 }
140
141 //sys getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getsockname
142
143 func Getsockname(fd int) (sa Sockaddr, err error) {
144 var rsa RawSockaddrAny
145 var len _Socklen = SizeofSockaddrAny
146 if err = getsockname(fd, &rsa, &len); err != nil {
147 return
148 }
149 return anyToSockaddr(fd, &rsa)
150 }
151
152 // GetsockoptString returns the string value of the socket option opt for the
153 // socket associated with fd at the given socket level.
154 func GetsockoptString(fd, level, opt int) (string, error) {
155 buf := make([]byte, 256)
156 vallen := _Socklen(len(buf))
157 err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
158 if err != nil {
159 return "", err
160 }
161 return ByteSliceToString(buf[:vallen]), nil
162 }
163
164 const ImplementsGetwd = true
165
166 //sys Getcwd(buf []byte) (n int, err error)
167
168 func Getwd() (wd string, err error) {
169 var buf [PathMax]byte
170 // Getcwd will return an error if it failed for any reason.
171 _, err = Getcwd(buf[0:])
172 if err != nil {
173 return "", err
174 }
175 n := clen(buf[:])
176 if n < 1 {
177 return "", EINVAL
178 }
179 return string(buf[:n]), nil
180 }
181
182 /*
183 * Wrapped
184 */
185
186 //sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error)
187 //sysnb setgroups(ngid int, gid *_Gid_t) (err error)
188
189 func Getgroups() (gids []int, err error) {
190 n, err := getgroups(0, nil)
191 // Check for error and sanity check group count. Newer versions of
192 // Solaris allow up to 1024 (NGROUPS_MAX).
193 if n < 0 || n > 1024 {
194 if err != nil {
195 return nil, err
196 }
197 return nil, EINVAL
198 } else if n == 0 {
199 return nil, nil
200 }
201
202 a := make([]_Gid_t, n)
203 n, err = getgroups(n, &a[0])
204 if n == -1 {
205 return nil, err
206 }
207 gids = make([]int, n)
208 for i, v := range a[0:n] {
209 gids[i] = int(v)
210 }
211 return
212 }
213
214 func Setgroups(gids []int) (err error) {
215 if len(gids) == 0 {
216 return setgroups(0, nil)
217 }
218
219 a := make([]_Gid_t, len(gids))
220 for i, v := range gids {
221 a[i] = _Gid_t(v)
222 }
223 return setgroups(len(a), &a[0])
224 }
225
226 // ReadDirent reads directory entries from fd and writes them into buf.
227 func ReadDirent(fd int, buf []byte) (n int, err error) {
228 // Final argument is (basep *uintptr) and the syscall doesn't take nil.
229 // TODO(rsc): Can we use a single global basep for all calls?
230 return Getdents(fd, buf, new(uintptr))
231 }
232
233 // Wait status is 7 bits at bottom, either 0 (exited),
234 // 0x7F (stopped), or a signal number that caused an exit.
235 // The 0x80 bit is whether there was a core dump.
236 // An extra number (exit code, signal causing a stop)
237 // is in the high bits.
238
239 type WaitStatus uint32
240
241 const (
242 mask = 0x7F
243 core = 0x80
244 shift = 8
245
246 exited = 0
247 stopped = 0x7F
248 )
249
250 func (w WaitStatus) Exited() bool { return w&mask == exited }
251
252 func (w WaitStatus) ExitStatus() int {
253 if w&mask != exited {
254 return -1
255 }
256 return int(w >> shift)
257 }
258
259 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
260
261 func (w WaitStatus) Signal() syscall.Signal {
262 sig := syscall.Signal(w & mask)
263 if sig == stopped || sig == 0 {
264 return -1
265 }
266 return sig
267 }
268
269 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
270
271 func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP }
272
273 func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP }
274
275 func (w WaitStatus) StopSignal() syscall.Signal {
276 if !w.Stopped() {
277 return -1
278 }
279 return syscall.Signal(w>>shift) & 0xFF
280 }
281
282 func (w WaitStatus) TrapCause() int { return -1 }
283
284 //sys wait4(pid int32, statusp *_C_int, options int, rusage *Rusage) (wpid int32, err error)
285
286 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (int, error) {
287 var status _C_int
288 rpid, err := wait4(int32(pid), &status, options, rusage)
289 wpid := int(rpid)
290 if wpid == -1 {
291 return wpid, err
292 }
293 if wstatus != nil {
294 *wstatus = WaitStatus(status)
295 }
296 return wpid, nil
297 }
298
299 //sys gethostname(buf []byte) (n int, err error)
300
301 func Gethostname() (name string, err error) {
302 var buf [MaxHostNameLen]byte
303 n, err := gethostname(buf[:])
304 if n != 0 {
305 return "", err
306 }
307 n = clen(buf[:])
308 if n < 1 {
309 return "", EFAULT
310 }
311 return string(buf[:n]), nil
312 }
313
314 //sys utimes(path string, times *[2]Timeval) (err error)
315
316 func Utimes(path string, tv []Timeval) (err error) {
317 if tv == nil {
318 return utimes(path, nil)
319 }
320 if len(tv) != 2 {
321 return EINVAL
322 }
323 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
324 }
325
326 //sys utimensat(fd int, path string, times *[2]Timespec, flag int) (err error)
327
328 func UtimesNano(path string, ts []Timespec) error {
329 if ts == nil {
330 return utimensat(AT_FDCWD, path, nil, 0)
331 }
332 if len(ts) != 2 {
333 return EINVAL
334 }
335 return utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
336 }
337
338 func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {
339 if ts == nil {
340 return utimensat(dirfd, path, nil, flags)
341 }
342 if len(ts) != 2 {
343 return EINVAL
344 }
345 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
346 }
347
348 //sys fcntl(fd int, cmd int, arg int) (val int, err error)
349
350 // FcntlInt performs a fcntl syscall on fd with the provided command and argument.
351 func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
352 valptr, _, errno := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
353 var err error
354 if errno != 0 {
355 err = errno
356 }
357 return int(valptr), err
358 }
359
360 // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
361 func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
362 _, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(unsafe.Pointer(lk)), 0, 0, 0)
363 if e1 != 0 {
364 return e1
365 }
366 return nil
367 }
368
369 //sys futimesat(fildes int, path *byte, times *[2]Timeval) (err error)
370
371 func Futimesat(dirfd int, path string, tv []Timeval) error {
372 pathp, err := BytePtrFromString(path)
373 if err != nil {
374 return err
375 }
376 if tv == nil {
377 return futimesat(dirfd, pathp, nil)
378 }
379 if len(tv) != 2 {
380 return EINVAL
381 }
382 return futimesat(dirfd, pathp, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
383 }
384
385 // Solaris doesn't have an futimes function because it allows NULL to be
386 // specified as the path for futimesat. However, Go doesn't like
387 // NULL-style string interfaces, so this simple wrapper is provided.
388 func Futimes(fd int, tv []Timeval) error {
389 if tv == nil {
390 return futimesat(fd, nil, nil)
391 }
392 if len(tv) != 2 {
393 return EINVAL
394 }
395 return futimesat(fd, nil, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
396 }
397
398 func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
399 switch rsa.Addr.Family {
400 case AF_UNIX:
401 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
402 sa := new(SockaddrUnix)
403 // Assume path ends at NUL.
404 // This is not technically the Solaris semantics for
405 // abstract Unix domain sockets -- they are supposed
406 // to be uninterpreted fixed-size binary blobs -- but
407 // everyone uses this convention.
408 n := 0
409 for n < len(pp.Path) && pp.Path[n] != 0 {
410 n++
411 }
412 sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
413 return sa, nil
414
415 case AF_INET:
416 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
417 sa := new(SockaddrInet4)
418 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
419 sa.Port = int(p[0])<<8 + int(p[1])
420 sa.Addr = pp.Addr
421 return sa, nil
422
423 case AF_INET6:
424 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
425 sa := new(SockaddrInet6)
426 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
427 sa.Port = int(p[0])<<8 + int(p[1])
428 sa.ZoneId = pp.Scope_id
429 sa.Addr = pp.Addr
430 return sa, nil
431 }
432 return nil, EAFNOSUPPORT
433 }
434
435 //sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) = libsocket.accept
436
437 func Accept(fd int) (nfd int, sa Sockaddr, err error) {
438 var rsa RawSockaddrAny
439 var len _Socklen = SizeofSockaddrAny
440 nfd, err = accept(fd, &rsa, &len)
441 if nfd == -1 {
442 return
443 }
444 sa, err = anyToSockaddr(fd, &rsa)
445 if err != nil {
446 Close(nfd)
447 nfd = 0
448 }
449 return
450 }
451
452 //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.__xnet_recvmsg
453
454 func recvmsgRaw(fd int, iov []Iovec, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, recvflags int, err error) {
455 var msg Msghdr
456 msg.Name = (*byte)(unsafe.Pointer(rsa))
457 msg.Namelen = uint32(SizeofSockaddrAny)
458 var dummy byte
459 if len(oob) > 0 {
460 // receive at least one normal byte
461 if emptyIovecs(iov) {
462 var iova [1]Iovec
463 iova[0].Base = &dummy
464 iova[0].SetLen(1)
465 iov = iova[:]
466 }
467 msg.Accrightslen = int32(len(oob))
468 }
469 if len(iov) > 0 {
470 msg.Iov = &iov[0]
471 msg.SetIovlen(len(iov))
472 }
473 if n, err = recvmsg(fd, &msg, flags); n == -1 {
474 return
475 }
476 oobn = int(msg.Accrightslen)
477 return
478 }
479
480 //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) = libsocket.__xnet_sendmsg
481
482 func sendmsgN(fd int, iov []Iovec, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
483 var msg Msghdr
484 msg.Name = (*byte)(unsafe.Pointer(ptr))
485 msg.Namelen = uint32(salen)
486 var dummy byte
487 var empty bool
488 if len(oob) > 0 {
489 // send at least one normal byte
490 empty = emptyIovecs(iov)
491 if empty {
492 var iova [1]Iovec
493 iova[0].Base = &dummy
494 iova[0].SetLen(1)
495 iov = iova[:]
496 }
497 msg.Accrightslen = int32(len(oob))
498 }
499 if len(iov) > 0 {
500 msg.Iov = &iov[0]
501 msg.SetIovlen(len(iov))
502 }
503 if n, err = sendmsg(fd, &msg, flags); err != nil {
504 return 0, err
505 }
506 if len(oob) > 0 && empty {
507 n = 0
508 }
509 return n, nil
510 }
511
512 //sys acct(path *byte) (err error)
513
514 func Acct(path string) (err error) {
515 if len(path) == 0 {
516 // Assume caller wants to disable accounting.
517 return acct(nil)
518 }
519
520 pathp, err := BytePtrFromString(path)
521 if err != nil {
522 return err
523 }
524 return acct(pathp)
525 }
526
527 //sys __makedev(version int, major uint, minor uint) (val uint64)
528
529 func Mkdev(major, minor uint32) uint64 {
530 return __makedev(NEWDEV, uint(major), uint(minor))
531 }
532
533 //sys __major(version int, dev uint64) (val uint)
534
535 func Major(dev uint64) uint32 {
536 return uint32(__major(NEWDEV, dev))
537 }
538
539 //sys __minor(version int, dev uint64) (val uint)
540
541 func Minor(dev uint64) uint32 {
542 return uint32(__minor(NEWDEV, dev))
543 }
544
545 /*
546 * Expose the ioctl function
547 */
548
549 //sys ioctlRet(fd int, req int, arg uintptr) (ret int, err error) = libc.ioctl
550 //sys ioctlPtrRet(fd int, req int, arg unsafe.Pointer) (ret int, err error) = libc.ioctl
551
552 func ioctl(fd int, req int, arg uintptr) (err error) {
553 _, err = ioctlRet(fd, req, arg)
554 return err
555 }
556
557 func ioctlPtr(fd int, req int, arg unsafe.Pointer) (err error) {
558 _, err = ioctlPtrRet(fd, req, arg)
559 return err
560 }
561
562 func IoctlSetTermio(fd int, req int, value *Termio) error {
563 return ioctlPtr(fd, req, unsafe.Pointer(value))
564 }
565
566 func IoctlGetTermio(fd int, req int) (*Termio, error) {
567 var value Termio
568 err := ioctlPtr(fd, req, unsafe.Pointer(&value))
569 return &value, err
570 }
571
572 //sys poll(fds *PollFd, nfds int, timeout int) (n int, err error)
573
574 func Poll(fds []PollFd, timeout int) (n int, err error) {
575 if len(fds) == 0 {
576 return poll(nil, 0, timeout)
577 }
578 return poll(&fds[0], len(fds), timeout)
579 }
580
581 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
582 if raceenabled {
583 raceReleaseMerge(unsafe.Pointer(&ioSync))
584 }
585 return sendfile(outfd, infd, offset, count)
586 }
587
588 /*
589 * Exposed directly
590 */
591 //sys Access(path string, mode uint32) (err error)
592 //sys Adjtime(delta *Timeval, olddelta *Timeval) (err error)
593 //sys Chdir(path string) (err error)
594 //sys Chmod(path string, mode uint32) (err error)
595 //sys Chown(path string, uid int, gid int) (err error)
596 //sys Chroot(path string) (err error)
597 //sys ClockGettime(clockid int32, time *Timespec) (err error)
598 //sys Close(fd int) (err error)
599 //sys Creat(path string, mode uint32) (fd int, err error)
600 //sys Dup(fd int) (nfd int, err error)
601 //sys Dup2(oldfd int, newfd int) (err error)
602 //sys Exit(code int)
603 //sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
604 //sys Fchdir(fd int) (err error)
605 //sys Fchmod(fd int, mode uint32) (err error)
606 //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
607 //sys Fchown(fd int, uid int, gid int) (err error)
608 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
609 //sys Fdatasync(fd int) (err error)
610 //sys Flock(fd int, how int) (err error)
611 //sys Fpathconf(fd int, name int) (val int, err error)
612 //sys Fstat(fd int, stat *Stat_t) (err error)
613 //sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
614 //sys Fstatvfs(fd int, vfsstat *Statvfs_t) (err error)
615 //sys Getdents(fd int, buf []byte, basep *uintptr) (n int, err error)
616 //sysnb Getgid() (gid int)
617 //sysnb Getpid() (pid int)
618 //sysnb Getpgid(pid int) (pgid int, err error)
619 //sysnb Getpgrp() (pgid int, err error)
620 //sys Geteuid() (euid int)
621 //sys Getegid() (egid int)
622 //sys Getppid() (ppid int)
623 //sys Getpriority(which int, who int) (n int, err error)
624 //sysnb Getrlimit(which int, lim *Rlimit) (err error)
625 //sysnb Getrusage(who int, rusage *Rusage) (err error)
626 //sysnb Getsid(pid int) (sid int, err error)
627 //sysnb Gettimeofday(tv *Timeval) (err error)
628 //sysnb Getuid() (uid int)
629 //sys Kill(pid int, signum syscall.Signal) (err error)
630 //sys Lchown(path string, uid int, gid int) (err error)
631 //sys Link(path string, link string) (err error)
632 //sys Listen(s int, backlog int) (err error) = libsocket.__xnet_listen
633 //sys Lstat(path string, stat *Stat_t) (err error)
634 //sys Madvise(b []byte, advice int) (err error)
635 //sys Mkdir(path string, mode uint32) (err error)
636 //sys Mkdirat(dirfd int, path string, mode uint32) (err error)
637 //sys Mkfifo(path string, mode uint32) (err error)
638 //sys Mkfifoat(dirfd int, path string, mode uint32) (err error)
639 //sys Mknod(path string, mode uint32, dev int) (err error)
640 //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
641 //sys Mlock(b []byte) (err error)
642 //sys Mlockall(flags int) (err error)
643 //sys Mprotect(b []byte, prot int) (err error)
644 //sys Msync(b []byte, flags int) (err error)
645 //sys Munlock(b []byte) (err error)
646 //sys Munlockall() (err error)
647 //sys Nanosleep(time *Timespec, leftover *Timespec) (err error)
648 //sys Open(path string, mode int, perm uint32) (fd int, err error)
649 //sys Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
650 //sys Pathconf(path string, name int) (val int, err error)
651 //sys Pause() (err error)
652 //sys pread(fd int, p []byte, offset int64) (n int, err error)
653 //sys pwrite(fd int, p []byte, offset int64) (n int, err error)
654 //sys read(fd int, p []byte) (n int, err error)
655 //sys Readlink(path string, buf []byte) (n int, err error)
656 //sys Rename(from string, to string) (err error)
657 //sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
658 //sys Rmdir(path string) (err error)
659 //sys Seek(fd int, offset int64, whence int) (newoffset int64, err error) = lseek
660 //sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
661 //sysnb Setegid(egid int) (err error)
662 //sysnb Seteuid(euid int) (err error)
663 //sysnb Setgid(gid int) (err error)
664 //sys Sethostname(p []byte) (err error)
665 //sysnb Setpgid(pid int, pgid int) (err error)
666 //sys Setpriority(which int, who int, prio int) (err error)
667 //sysnb Setregid(rgid int, egid int) (err error)
668 //sysnb Setreuid(ruid int, euid int) (err error)
669 //sysnb Setsid() (pid int, err error)
670 //sysnb Setuid(uid int) (err error)
671 //sys Shutdown(s int, how int) (err error) = libsocket.shutdown
672 //sys Stat(path string, stat *Stat_t) (err error)
673 //sys Statvfs(path string, vfsstat *Statvfs_t) (err error)
674 //sys Symlink(path string, link string) (err error)
675 //sys Sync() (err error)
676 //sys Sysconf(which int) (n int64, err error)
677 //sysnb Times(tms *Tms) (ticks uintptr, err error)
678 //sys Truncate(path string, length int64) (err error)
679 //sys Fsync(fd int) (err error)
680 //sys Ftruncate(fd int, length int64) (err error)
681 //sys Umask(mask int) (oldmask int)
682 //sysnb Uname(buf *Utsname) (err error)
683 //sys Unmount(target string, flags int) (err error) = libc.umount
684 //sys Unlink(path string) (err error)
685 //sys Unlinkat(dirfd int, path string, flags int) (err error)
686 //sys Ustat(dev int, ubuf *Ustat_t) (err error)
687 //sys Utime(path string, buf *Utimbuf) (err error)
688 //sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_bind
689 //sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_connect
690 //sys mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error)
691 //sys munmap(addr uintptr, length uintptr) (err error)
692 //sys sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) = libsendfile.sendfile
693 //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) = libsocket.__xnet_sendto
694 //sys socket(domain int, typ int, proto int) (fd int, err error) = libsocket.__xnet_socket
695 //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) = libsocket.__xnet_socketpair
696 //sys write(fd int, p []byte) (n int, err error)
697 //sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) = libsocket.__xnet_getsockopt
698 //sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) = libsocket.getpeername
699 //sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) = libsocket.setsockopt
700 //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) = libsocket.recvfrom
701
702 // Event Ports
703
704 type fileObjCookie struct {
705 fobj *fileObj
706 cookie interface{}
707 }
708
709 // EventPort provides a safe abstraction on top of Solaris/illumos Event Ports.
710 type EventPort struct {
711 port int
712 mu sync.Mutex
713 fds map[uintptr]*fileObjCookie
714 paths map[string]*fileObjCookie
715 // The user cookie presents an interesting challenge from a memory management perspective.
716 // There are two paths by which we can discover that it is no longer in use:
717 // 1. The user calls port_dissociate before any events fire
718 // 2. An event fires and we return it to the user
719 // The tricky situation is if the event has fired in the kernel but
720 // the user hasn't requested/received it yet.
721 // If the user wants to port_dissociate before the event has been processed,
722 // we should handle things gracefully. To do so, we need to keep an extra
723 // reference to the cookie around until the event is processed
724 // thus the otherwise seemingly extraneous "cookies" map
725 // The key of this map is a pointer to the corresponding fCookie
726 cookies map[*fileObjCookie]struct{}
727 }
728
729 // PortEvent is an abstraction of the port_event C struct.
730 // Compare Source against PORT_SOURCE_FILE or PORT_SOURCE_FD
731 // to see if Path or Fd was the event source. The other will be
732 // uninitialized.
733 type PortEvent struct {
734 Cookie interface{}
735 Events int32
736 Fd uintptr
737 Path string
738 Source uint16
739 fobj *fileObj
740 }
741
742 // NewEventPort creates a new EventPort including the
743 // underlying call to port_create(3c).
744 func NewEventPort() (*EventPort, error) {
745 port, err := port_create()
746 if err != nil {
747 return nil, err
748 }
749 e := &EventPort{
750 port: port,
751 fds: make(map[uintptr]*fileObjCookie),
752 paths: make(map[string]*fileObjCookie),
753 cookies: make(map[*fileObjCookie]struct{}),
754 }
755 return e, nil
756 }
757
758 //sys port_create() (n int, err error)
759 //sys port_associate(port int, source int, object uintptr, events int, user *byte) (n int, err error)
760 //sys port_dissociate(port int, source int, object uintptr) (n int, err error)
761 //sys port_get(port int, pe *portEvent, timeout *Timespec) (n int, err error)
762 //sys port_getn(port int, pe *portEvent, max uint32, nget *uint32, timeout *Timespec) (n int, err error)
763
764 // Close closes the event port.
765 func (e *EventPort) Close() error {
766 e.mu.Lock()
767 defer e.mu.Unlock()
768 err := Close(e.port)
769 if err != nil {
770 return err
771 }
772 e.fds = nil
773 e.paths = nil
774 e.cookies = nil
775 return nil
776 }
777
778 // PathIsWatched checks to see if path is associated with this EventPort.
779 func (e *EventPort) PathIsWatched(path string) bool {
780 e.mu.Lock()
781 defer e.mu.Unlock()
782 _, found := e.paths[path]
783 return found
784 }
785
786 // FdIsWatched checks to see if fd is associated with this EventPort.
787 func (e *EventPort) FdIsWatched(fd uintptr) bool {
788 e.mu.Lock()
789 defer e.mu.Unlock()
790 _, found := e.fds[fd]
791 return found
792 }
793
794 // AssociatePath wraps port_associate(3c) for a filesystem path including
795 // creating the necessary file_obj from the provided stat information.
796 func (e *EventPort) AssociatePath(path string, stat os.FileInfo, events int, cookie interface{}) error {
797 e.mu.Lock()
798 defer e.mu.Unlock()
799 if _, found := e.paths[path]; found {
800 return fmt.Errorf("%v is already associated with this Event Port", path)
801 }
802 fCookie, err := createFileObjCookie(path, stat, cookie)
803 if err != nil {
804 return err
805 }
806 _, err = port_associate(e.port, PORT_SOURCE_FILE, uintptr(unsafe.Pointer(fCookie.fobj)), events, (*byte)(unsafe.Pointer(fCookie)))
807 if err != nil {
808 return err
809 }
810 e.paths[path] = fCookie
811 e.cookies[fCookie] = struct{}{}
812 return nil
813 }
814
815 // DissociatePath wraps port_dissociate(3c) for a filesystem path.
816 func (e *EventPort) DissociatePath(path string) error {
817 e.mu.Lock()
818 defer e.mu.Unlock()
819 f, ok := e.paths[path]
820 if !ok {
821 return fmt.Errorf("%v is not associated with this Event Port", path)
822 }
823 _, err := port_dissociate(e.port, PORT_SOURCE_FILE, uintptr(unsafe.Pointer(f.fobj)))
824 // If the path is no longer associated with this event port (ENOENT)
825 // we should delete it from our map. We can still return ENOENT to the caller.
826 // But we need to save the cookie
827 if err != nil && err != ENOENT {
828 return err
829 }
830 if err == nil {
831 // dissociate was successful, safe to delete the cookie
832 fCookie := e.paths[path]
833 delete(e.cookies, fCookie)
834 }
835 delete(e.paths, path)
836 return err
837 }
838
839 // AssociateFd wraps calls to port_associate(3c) on file descriptors.
840 func (e *EventPort) AssociateFd(fd uintptr, events int, cookie interface{}) error {
841 e.mu.Lock()
842 defer e.mu.Unlock()
843 if _, found := e.fds[fd]; found {
844 return fmt.Errorf("%v is already associated with this Event Port", fd)
845 }
846 fCookie, err := createFileObjCookie("", nil, cookie)
847 if err != nil {
848 return err
849 }
850 _, err = port_associate(e.port, PORT_SOURCE_FD, fd, events, (*byte)(unsafe.Pointer(fCookie)))
851 if err != nil {
852 return err
853 }
854 e.fds[fd] = fCookie
855 e.cookies[fCookie] = struct{}{}
856 return nil
857 }
858
859 // DissociateFd wraps calls to port_dissociate(3c) on file descriptors.
860 func (e *EventPort) DissociateFd(fd uintptr) error {
861 e.mu.Lock()
862 defer e.mu.Unlock()
863 _, ok := e.fds[fd]
864 if !ok {
865 return fmt.Errorf("%v is not associated with this Event Port", fd)
866 }
867 _, err := port_dissociate(e.port, PORT_SOURCE_FD, fd)
868 if err != nil && err != ENOENT {
869 return err
870 }
871 if err == nil {
872 // dissociate was successful, safe to delete the cookie
873 fCookie := e.fds[fd]
874 delete(e.cookies, fCookie)
875 }
876 delete(e.fds, fd)
877 return err
878 }
879
880 func createFileObjCookie(name string, stat os.FileInfo, cookie interface{}) (*fileObjCookie, error) {
881 fCookie := new(fileObjCookie)
882 fCookie.cookie = cookie
883 if name != "" && stat != nil {
884 fCookie.fobj = new(fileObj)
885 bs, err := ByteSliceFromString(name)
886 if err != nil {
887 return nil, err
888 }
889 fCookie.fobj.Name = (*int8)(unsafe.Pointer(&bs[0]))
890 s := stat.Sys().(*syscall.Stat_t)
891 fCookie.fobj.Atim.Sec = s.Atim.Sec
892 fCookie.fobj.Atim.Nsec = s.Atim.Nsec
893 fCookie.fobj.Mtim.Sec = s.Mtim.Sec
894 fCookie.fobj.Mtim.Nsec = s.Mtim.Nsec
895 fCookie.fobj.Ctim.Sec = s.Ctim.Sec
896 fCookie.fobj.Ctim.Nsec = s.Ctim.Nsec
897 }
898 return fCookie, nil
899 }
900
901 // GetOne wraps port_get(3c) and returns a single PortEvent.
902 func (e *EventPort) GetOne(t *Timespec) (*PortEvent, error) {
903 pe := new(portEvent)
904 _, err := port_get(e.port, pe, t)
905 if err != nil {
906 return nil, err
907 }
908 p := new(PortEvent)
909 e.mu.Lock()
910 defer e.mu.Unlock()
911 err = e.peIntToExt(pe, p)
912 if err != nil {
913 return nil, err
914 }
915 return p, nil
916 }
917
918 // peIntToExt converts a cgo portEvent struct into the friendlier PortEvent
919 // NOTE: Always call this function while holding the e.mu mutex
920 func (e *EventPort) peIntToExt(peInt *portEvent, peExt *PortEvent) error {
921 if e.cookies == nil {
922 return fmt.Errorf("this EventPort is already closed")
923 }
924 peExt.Events = peInt.Events
925 peExt.Source = peInt.Source
926 fCookie := (*fileObjCookie)(unsafe.Pointer(peInt.User))
927 _, found := e.cookies[fCookie]
928
929 if !found {
930 panic("unexpected event port address; may be due to kernel bug; see https://go.dev/issue/54254")
931 }
932 peExt.Cookie = fCookie.cookie
933 delete(e.cookies, fCookie)
934
935 switch peInt.Source {
936 case PORT_SOURCE_FD:
937 peExt.Fd = uintptr(peInt.Object)
938 // Only remove the fds entry if it exists and this cookie matches
939 if fobj, ok := e.fds[peExt.Fd]; ok {
940 if fobj == fCookie {
941 delete(e.fds, peExt.Fd)
942 }
943 }
944 case PORT_SOURCE_FILE:
945 peExt.fobj = fCookie.fobj
946 peExt.Path = BytePtrToString((*byte)(unsafe.Pointer(peExt.fobj.Name)))
947 // Only remove the paths entry if it exists and this cookie matches
948 if fobj, ok := e.paths[peExt.Path]; ok {
949 if fobj == fCookie {
950 delete(e.paths, peExt.Path)
951 }
952 }
953 }
954 return nil
955 }
956
957 // Pending wraps port_getn(3c) and returns how many events are pending.
958 func (e *EventPort) Pending() (int, error) {
959 var n uint32 = 0
960 _, err := port_getn(e.port, nil, 0, &n, nil)
961 return int(n), err
962 }
963
964 // Get wraps port_getn(3c) and fills a slice of PortEvent.
965 // It will block until either min events have been received
966 // or the timeout has been exceeded. It will return how many
967 // events were actually received along with any error information.
968 func (e *EventPort) Get(s []PortEvent, min int, timeout *Timespec) (int, error) {
969 if min == 0 {
970 return 0, fmt.Errorf("need to request at least one event or use Pending() instead")
971 }
972 if len(s) < min {
973 return 0, fmt.Errorf("len(s) (%d) is less than min events requested (%d)", len(s), min)
974 }
975 got := uint32(min)
976 max := uint32(len(s))
977 var err error
978 ps := make([]portEvent, max)
979 _, err = port_getn(e.port, &ps[0], max, &got, timeout)
980 // got will be trustworthy with ETIME, but not any other error.
981 if err != nil && err != ETIME {
982 return 0, err
983 }
984 e.mu.Lock()
985 defer e.mu.Unlock()
986 valid := 0
987 for i := 0; i < int(got); i++ {
988 err2 := e.peIntToExt(&ps[i], &s[i])
989 if err2 != nil {
990 if valid == 0 && err == nil {
991 // If err2 is the only error and there are no valid events
992 // to return, return it to the caller.
993 err = err2
994 }
995 break
996 }
997 valid = i + 1
998 }
999 return valid, err
1000 }
1001
1002 //sys putmsg(fd int, clptr *strbuf, dataptr *strbuf, flags int) (err error)
1003
1004 func Putmsg(fd int, cl []byte, data []byte, flags int) (err error) {
1005 var clp, datap *strbuf
1006 if len(cl) > 0 {
1007 clp = &strbuf{
1008 Len: int32(len(cl)),
1009 Buf: (*int8)(unsafe.Pointer(&cl[0])),
1010 }
1011 }
1012 if len(data) > 0 {
1013 datap = &strbuf{
1014 Len: int32(len(data)),
1015 Buf: (*int8)(unsafe.Pointer(&data[0])),
1016 }
1017 }
1018 return putmsg(fd, clp, datap, flags)
1019 }
1020
1021 //sys getmsg(fd int, clptr *strbuf, dataptr *strbuf, flags *int) (err error)
1022
1023 func Getmsg(fd int, cl []byte, data []byte) (retCl []byte, retData []byte, flags int, err error) {
1024 var clp, datap *strbuf
1025 if len(cl) > 0 {
1026 clp = &strbuf{
1027 Maxlen: int32(len(cl)),
1028 Buf: (*int8)(unsafe.Pointer(&cl[0])),
1029 }
1030 }
1031 if len(data) > 0 {
1032 datap = &strbuf{
1033 Maxlen: int32(len(data)),
1034 Buf: (*int8)(unsafe.Pointer(&data[0])),
1035 }
1036 }
1037
1038 if err = getmsg(fd, clp, datap, &flags); err != nil {
1039 return nil, nil, 0, err
1040 }
1041
1042 if len(cl) > 0 {
1043 retCl = cl[:clp.Len]
1044 }
1045 if len(data) > 0 {
1046 retData = data[:datap.Len]
1047 }
1048 return retCl, retData, flags, nil
1049 }
1050
1051 func IoctlSetIntRetInt(fd int, req int, arg int) (int, error) {
1052 return ioctlRet(fd, req, uintptr(arg))
1053 }
1054
1055 // Lifreq Helpers
1056
1057 func (l *Lifreq) SetName(name string) error {
1058 if len(name) >= len(l.Name) {
1059 return fmt.Errorf("name cannot be more than %d characters", len(l.Name)-1)
1060 }
1061 for i := range name {
1062 l.Name[i] = int8(name[i])
1063 }
1064 return nil
1065 }
1066
1067 func (l *Lifreq) SetLifruInt(d int) {
1068 *(*int)(unsafe.Pointer(&l.Lifru[0])) = d
1069 }
1070
1071 func (l *Lifreq) GetLifruInt() int {
1072 return *(*int)(unsafe.Pointer(&l.Lifru[0]))
1073 }
1074
1075 func (l *Lifreq) SetLifruUint(d uint) {
1076 *(*uint)(unsafe.Pointer(&l.Lifru[0])) = d
1077 }
1078
1079 func (l *Lifreq) GetLifruUint() uint {
1080 return *(*uint)(unsafe.Pointer(&l.Lifru[0]))
1081 }
1082
1083 func IoctlLifreq(fd int, req int, l *Lifreq) error {
1084 return ioctlPtr(fd, req, unsafe.Pointer(l))
1085 }
1086
1087 // Strioctl Helpers
1088
1089 func (s *Strioctl) SetInt(i int) {
1090 s.Len = int32(unsafe.Sizeof(i))
1091 s.Dp = (*int8)(unsafe.Pointer(&i))
1092 }
1093
1094 func IoctlSetStrioctlRetInt(fd int, req int, s *Strioctl) (int, error) {
1095 return ioctlPtrRet(fd, req, unsafe.Pointer(s))
1096 }
1097
1098 // Ucred Helpers
1099 // See ucred(3c) and getpeerucred(3c)
1100
1101 //sys getpeerucred(fd uintptr, ucred *uintptr) (err error)
1102 //sys ucredFree(ucred uintptr) = ucred_free
1103 //sys ucredGet(pid int) (ucred uintptr, err error) = ucred_get
1104 //sys ucredGeteuid(ucred uintptr) (uid int) = ucred_geteuid
1105 //sys ucredGetegid(ucred uintptr) (gid int) = ucred_getegid
1106 //sys ucredGetruid(ucred uintptr) (uid int) = ucred_getruid
1107 //sys ucredGetrgid(ucred uintptr) (gid int) = ucred_getrgid
1108 //sys ucredGetsuid(ucred uintptr) (uid int) = ucred_getsuid
1109 //sys ucredGetsgid(ucred uintptr) (gid int) = ucred_getsgid
1110 //sys ucredGetpid(ucred uintptr) (pid int) = ucred_getpid
1111
1112 // Ucred is an opaque struct that holds user credentials.
1113 type Ucred struct {
1114 ucred uintptr
1115 }
1116
1117 // We need to ensure that ucredFree is called on the underlying ucred
1118 // when the Ucred is garbage collected.
1119 func ucredFinalizer(u *Ucred) {
1120 ucredFree(u.ucred)
1121 }
1122
1123 func GetPeerUcred(fd uintptr) (*Ucred, error) {
1124 var ucred uintptr
1125 err := getpeerucred(fd, &ucred)
1126 if err != nil {
1127 return nil, err
1128 }
1129 result := &Ucred{
1130 ucred: ucred,
1131 }
1132 // set the finalizer on the result so that the ucred will be freed
1133 runtime.SetFinalizer(result, ucredFinalizer)
1134 return result, nil
1135 }
1136
1137 func UcredGet(pid int) (*Ucred, error) {
1138 ucred, err := ucredGet(pid)
1139 if err != nil {
1140 return nil, err
1141 }
1142 result := &Ucred{
1143 ucred: ucred,
1144 }
1145 // set the finalizer on the result so that the ucred will be freed
1146 runtime.SetFinalizer(result, ucredFinalizer)
1147 return result, nil
1148 }
1149
1150 func (u *Ucred) Geteuid() int {
1151 defer runtime.KeepAlive(u)
1152 return ucredGeteuid(u.ucred)
1153 }
1154
1155 func (u *Ucred) Getruid() int {
1156 defer runtime.KeepAlive(u)
1157 return ucredGetruid(u.ucred)
1158 }
1159
1160 func (u *Ucred) Getsuid() int {
1161 defer runtime.KeepAlive(u)
1162 return ucredGetsuid(u.ucred)
1163 }
1164
1165 func (u *Ucred) Getegid() int {
1166 defer runtime.KeepAlive(u)
1167 return ucredGetegid(u.ucred)
1168 }
1169
1170 func (u *Ucred) Getrgid() int {
1171 defer runtime.KeepAlive(u)
1172 return ucredGetrgid(u.ucred)
1173 }
1174
1175 func (u *Ucred) Getsgid() int {
1176 defer runtime.KeepAlive(u)
1177 return ucredGetsgid(u.ucred)
1178 }
1179
1180 func (u *Ucred) Getpid() int {
1181 defer runtime.KeepAlive(u)
1182 return ucredGetpid(u.ucred)
1183 }
1184