|
66
|
1 // Copyright 2021 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 // illumos system calls not present on Solaris.
|
|
|
6
|
|
|
7 //go:build amd64 && illumos
|
|
|
8 // +build amd64,illumos
|
|
|
9
|
|
|
10 package unix
|
|
|
11
|
|
|
12 import (
|
|
|
13 "fmt"
|
|
|
14 "runtime"
|
|
|
15 "unsafe"
|
|
|
16 )
|
|
|
17
|
|
|
18 func bytes2iovec(bs [][]byte) []Iovec {
|
|
|
19 iovecs := make([]Iovec, len(bs))
|
|
|
20 for i, b := range bs {
|
|
|
21 iovecs[i].SetLen(len(b))
|
|
|
22 if len(b) > 0 {
|
|
|
23 iovecs[i].Base = &b[0]
|
|
|
24 } else {
|
|
|
25 iovecs[i].Base = (*byte)(unsafe.Pointer(&_zero))
|
|
|
26 }
|
|
|
27 }
|
|
|
28 return iovecs
|
|
|
29 }
|
|
|
30
|
|
|
31 //sys readv(fd int, iovs []Iovec) (n int, err error)
|
|
|
32
|
|
|
33 func Readv(fd int, iovs [][]byte) (n int, err error) {
|
|
|
34 iovecs := bytes2iovec(iovs)
|
|
|
35 n, err = readv(fd, iovecs)
|
|
|
36 return n, err
|
|
|
37 }
|
|
|
38
|
|
|
39 //sys preadv(fd int, iovs []Iovec, off int64) (n int, err error)
|
|
|
40
|
|
|
41 func Preadv(fd int, iovs [][]byte, off int64) (n int, err error) {
|
|
|
42 iovecs := bytes2iovec(iovs)
|
|
|
43 n, err = preadv(fd, iovecs, off)
|
|
|
44 return n, err
|
|
|
45 }
|
|
|
46
|
|
|
47 //sys writev(fd int, iovs []Iovec) (n int, err error)
|
|
|
48
|
|
|
49 func Writev(fd int, iovs [][]byte) (n int, err error) {
|
|
|
50 iovecs := bytes2iovec(iovs)
|
|
|
51 n, err = writev(fd, iovecs)
|
|
|
52 return n, err
|
|
|
53 }
|
|
|
54
|
|
|
55 //sys pwritev(fd int, iovs []Iovec, off int64) (n int, err error)
|
|
|
56
|
|
|
57 func Pwritev(fd int, iovs [][]byte, off int64) (n int, err error) {
|
|
|
58 iovecs := bytes2iovec(iovs)
|
|
|
59 n, err = pwritev(fd, iovecs, off)
|
|
|
60 return n, err
|
|
|
61 }
|
|
|
62
|
|
|
63 //sys accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) = libsocket.accept4
|
|
|
64
|
|
|
65 func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
|
|
|
66 var rsa RawSockaddrAny
|
|
|
67 var len _Socklen = SizeofSockaddrAny
|
|
|
68 nfd, err = accept4(fd, &rsa, &len, flags)
|
|
|
69 if err != nil {
|
|
|
70 return
|
|
|
71 }
|
|
|
72 if len > SizeofSockaddrAny {
|
|
|
73 panic("RawSockaddrAny too small")
|
|
|
74 }
|
|
|
75 sa, err = anyToSockaddr(fd, &rsa)
|
|
|
76 if err != nil {
|
|
|
77 Close(nfd)
|
|
|
78 nfd = 0
|
|
|
79 }
|
|
|
80 return
|
|
|
81 }
|
|
|
82
|
|
|
83 //sys putmsg(fd int, clptr *strbuf, dataptr *strbuf, flags int) (err error)
|
|
|
84
|
|
|
85 func Putmsg(fd int, cl []byte, data []byte, flags int) (err error) {
|
|
|
86 var clp, datap *strbuf
|
|
|
87 if len(cl) > 0 {
|
|
|
88 clp = &strbuf{
|
|
|
89 Len: int32(len(cl)),
|
|
|
90 Buf: (*int8)(unsafe.Pointer(&cl[0])),
|
|
|
91 }
|
|
|
92 }
|
|
|
93 if len(data) > 0 {
|
|
|
94 datap = &strbuf{
|
|
|
95 Len: int32(len(data)),
|
|
|
96 Buf: (*int8)(unsafe.Pointer(&data[0])),
|
|
|
97 }
|
|
|
98 }
|
|
|
99 return putmsg(fd, clp, datap, flags)
|
|
|
100 }
|
|
|
101
|
|
|
102 //sys getmsg(fd int, clptr *strbuf, dataptr *strbuf, flags *int) (err error)
|
|
|
103
|
|
|
104 func Getmsg(fd int, cl []byte, data []byte) (retCl []byte, retData []byte, flags int, err error) {
|
|
|
105 var clp, datap *strbuf
|
|
|
106 if len(cl) > 0 {
|
|
|
107 clp = &strbuf{
|
|
|
108 Maxlen: int32(len(cl)),
|
|
|
109 Buf: (*int8)(unsafe.Pointer(&cl[0])),
|
|
|
110 }
|
|
|
111 }
|
|
|
112 if len(data) > 0 {
|
|
|
113 datap = &strbuf{
|
|
|
114 Maxlen: int32(len(data)),
|
|
|
115 Buf: (*int8)(unsafe.Pointer(&data[0])),
|
|
|
116 }
|
|
|
117 }
|
|
|
118
|
|
|
119 if err = getmsg(fd, clp, datap, &flags); err != nil {
|
|
|
120 return nil, nil, 0, err
|
|
|
121 }
|
|
|
122
|
|
|
123 if len(cl) > 0 {
|
|
|
124 retCl = cl[:clp.Len]
|
|
|
125 }
|
|
|
126 if len(data) > 0 {
|
|
|
127 retData = data[:datap.Len]
|
|
|
128 }
|
|
|
129 return retCl, retData, flags, nil
|
|
|
130 }
|
|
|
131
|
|
|
132 func IoctlSetIntRetInt(fd int, req uint, arg int) (int, error) {
|
|
|
133 return ioctlRet(fd, req, uintptr(arg))
|
|
|
134 }
|
|
|
135
|
|
|
136 func IoctlSetString(fd int, req uint, val string) error {
|
|
|
137 bs := make([]byte, len(val)+1)
|
|
|
138 copy(bs[:len(bs)-1], val)
|
|
|
139 err := ioctl(fd, req, uintptr(unsafe.Pointer(&bs[0])))
|
|
|
140 runtime.KeepAlive(&bs[0])
|
|
|
141 return err
|
|
|
142 }
|
|
|
143
|
|
|
144 // Lifreq Helpers
|
|
|
145
|
|
|
146 func (l *Lifreq) SetName(name string) error {
|
|
|
147 if len(name) >= len(l.Name) {
|
|
|
148 return fmt.Errorf("name cannot be more than %d characters", len(l.Name)-1)
|
|
|
149 }
|
|
|
150 for i := range name {
|
|
|
151 l.Name[i] = int8(name[i])
|
|
|
152 }
|
|
|
153 return nil
|
|
|
154 }
|
|
|
155
|
|
|
156 func (l *Lifreq) SetLifruInt(d int) {
|
|
|
157 *(*int)(unsafe.Pointer(&l.Lifru[0])) = d
|
|
|
158 }
|
|
|
159
|
|
|
160 func (l *Lifreq) GetLifruInt() int {
|
|
|
161 return *(*int)(unsafe.Pointer(&l.Lifru[0]))
|
|
|
162 }
|
|
|
163
|
|
|
164 func (l *Lifreq) SetLifruUint(d uint) {
|
|
|
165 *(*uint)(unsafe.Pointer(&l.Lifru[0])) = d
|
|
|
166 }
|
|
|
167
|
|
|
168 func (l *Lifreq) GetLifruUint() uint {
|
|
|
169 return *(*uint)(unsafe.Pointer(&l.Lifru[0]))
|
|
|
170 }
|
|
|
171
|
|
|
172 func IoctlLifreq(fd int, req uint, l *Lifreq) error {
|
|
|
173 return ioctl(fd, req, uintptr(unsafe.Pointer(l)))
|
|
|
174 }
|
|
|
175
|
|
|
176 // Strioctl Helpers
|
|
|
177
|
|
|
178 func (s *Strioctl) SetInt(i int) {
|
|
|
179 s.Len = int32(unsafe.Sizeof(i))
|
|
|
180 s.Dp = (*int8)(unsafe.Pointer(&i))
|
|
|
181 }
|
|
|
182
|
|
|
183 func IoctlSetStrioctlRetInt(fd int, req uint, s *Strioctl) (int, error) {
|
|
|
184 return ioctlRet(fd, req, uintptr(unsafe.Pointer(s)))
|
|
|
185 }
|
