github.com/zach-klippenstein/go@v0.0.0-20150108044943-fcfbeb3adf58/src/runtime/syscall_solaris.go (about) 1 // Copyright 2014 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 package runtime 6 7 import "unsafe" 8 9 var ( 10 libc_chdir, 11 libc_chroot, 12 libc_dlopen, 13 libc_dlclose, 14 libc_dlsym, 15 libc_execve, 16 libc_fcntl, 17 libc_forkx, 18 libc_gethostname, 19 libc_ioctl, 20 libc_pipe, 21 libc_setgid, 22 libc_setgroups, 23 libc_setsid, 24 libc_setuid, 25 libc_setpgid, 26 libc_syscall, 27 libc_wait4, 28 pipe1 libcFunc 29 ) 30 31 //go:nosplit 32 func syscall_sysvicall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 33 call := libcall{ 34 fn: fn, 35 n: nargs, 36 args: uintptr(unsafe.Pointer(&a1)), 37 } 38 entersyscallblock(0) 39 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 40 exitsyscall(0) 41 return call.r1, call.r2, call.err 42 } 43 44 //go:nosplit 45 func syscall_rawsysvicall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 46 call := libcall{ 47 fn: fn, 48 n: nargs, 49 args: uintptr(unsafe.Pointer(&a1)), 50 } 51 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 52 return call.r1, call.r2, call.err 53 } 54 55 // TODO(aram): Once we remove all instances of C calling sysvicallN, make 56 // sysvicallN return errors and replace the body of the following functions 57 // with calls to sysvicallN. 58 59 //go:nosplit 60 func syscall_chdir(path uintptr) (err uintptr) { 61 call := libcall{ 62 fn: uintptr(unsafe.Pointer(libc_chdir)), 63 n: 1, 64 args: uintptr(unsafe.Pointer(&path)), 65 } 66 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 67 return call.err 68 } 69 70 //go:nosplit 71 func syscall_chroot(path uintptr) (err uintptr) { 72 call := libcall{ 73 fn: uintptr(unsafe.Pointer(libc_chroot)), 74 n: 1, 75 args: uintptr(unsafe.Pointer(&path)), 76 } 77 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 78 return call.err 79 } 80 81 // like close, but must not split stack, for forkx. 82 //go:nosplit 83 func syscall_close(fd int32) int32 { 84 return int32(sysvicall1(libc_close, uintptr(fd))) 85 } 86 87 func syscall_dlopen(name *byte, mode uintptr) (handle uintptr, err uintptr) { 88 call := libcall{ 89 fn: uintptr(unsafe.Pointer(libc_dlopen)), 90 n: 2, 91 args: uintptr(unsafe.Pointer(&name)), 92 } 93 entersyscallblock(0) 94 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 95 exitsyscall(0) 96 if call.r1 == 0 { 97 return call.r1, call.err 98 } 99 return call.r1, 0 100 } 101 102 func syscall_dlclose(handle uintptr) (err uintptr) { 103 call := libcall{ 104 fn: uintptr(unsafe.Pointer(libc_dlclose)), 105 n: 1, 106 args: uintptr(unsafe.Pointer(&handle)), 107 } 108 entersyscallblock(0) 109 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 110 exitsyscall(0) 111 return call.r1 112 } 113 114 func syscall_dlsym(handle uintptr, name *byte) (proc uintptr, err uintptr) { 115 call := libcall{ 116 fn: uintptr(unsafe.Pointer(libc_dlsym)), 117 n: 2, 118 args: uintptr(unsafe.Pointer(&handle)), 119 } 120 entersyscallblock(0) 121 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 122 exitsyscall(0) 123 if call.r1 == 0 { 124 return call.r1, call.err 125 } 126 return call.r1, 0 127 } 128 129 //go:nosplit 130 func syscall_execve(path, argv, envp uintptr) (err uintptr) { 131 call := libcall{ 132 fn: uintptr(unsafe.Pointer(libc_execve)), 133 n: 3, 134 args: uintptr(unsafe.Pointer(&path)), 135 } 136 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 137 return call.err 138 } 139 140 // like exit, but must not split stack, for forkx. 141 //go:nosplit 142 func syscall_exit(code uintptr) { 143 sysvicall1(libc_exit, code) 144 } 145 146 //go:nosplit 147 func syscall_fcntl(fd, cmd, arg uintptr) (val, err uintptr) { 148 call := libcall{ 149 fn: uintptr(unsafe.Pointer(libc_fcntl)), 150 n: 3, 151 args: uintptr(unsafe.Pointer(&fd)), 152 } 153 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 154 return call.r1, call.err 155 } 156 157 //go:nosplit 158 func syscall_forkx(flags uintptr) (pid uintptr, err uintptr) { 159 call := libcall{ 160 fn: uintptr(unsafe.Pointer(libc_forkx)), 161 n: 1, 162 args: uintptr(unsafe.Pointer(&flags)), 163 } 164 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 165 return call.r1, call.err 166 } 167 168 func syscall_gethostname() (name string, err uintptr) { 169 cname := new([_MAXHOSTNAMELEN]byte) 170 var args = [2]uintptr{uintptr(unsafe.Pointer(&cname[0])), _MAXHOSTNAMELEN} 171 call := libcall{ 172 fn: uintptr(unsafe.Pointer(libc_gethostname)), 173 n: 2, 174 args: uintptr(unsafe.Pointer(&args[0])), 175 } 176 entersyscallblock(0) 177 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 178 exitsyscall(0) 179 if call.r1 != 0 { 180 return "", call.err 181 } 182 cname[_MAXHOSTNAMELEN-1] = 0 183 return gostringnocopy(&cname[0]), 0 184 } 185 186 //go:nosplit 187 func syscall_ioctl(fd, req, arg uintptr) (err uintptr) { 188 call := libcall{ 189 fn: uintptr(unsafe.Pointer(libc_ioctl)), 190 n: 3, 191 args: uintptr(unsafe.Pointer(&fd)), 192 } 193 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 194 return call.err 195 } 196 197 func syscall_pipe() (r, w, err uintptr) { 198 call := libcall{ 199 fn: uintptr(unsafe.Pointer(&pipe1)), 200 n: 0, 201 args: uintptr(unsafe.Pointer(&pipe1)), // it's unused but must be non-nil, otherwise crashes 202 } 203 entersyscallblock(0) 204 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 205 exitsyscall(0) 206 return call.r1, call.r2, call.err 207 } 208 209 // This is syscall.RawSyscall, it exists to satisfy some build dependency, 210 // but it doesn't work correctly. 211 // 212 // DO NOT USE! 213 // 214 // TODO(aram): make this panic once we stop calling fcntl(2) in net using it. 215 func syscall_rawsyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 216 call := libcall{ 217 fn: uintptr(unsafe.Pointer(libc_syscall)), 218 n: 4, 219 args: uintptr(unsafe.Pointer(&trap)), 220 } 221 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 222 return call.r1, call.r2, call.err 223 } 224 225 //go:nosplit 226 func syscall_setgid(gid uintptr) (err uintptr) { 227 call := libcall{ 228 fn: uintptr(unsafe.Pointer(libc_setgid)), 229 n: 1, 230 args: uintptr(unsafe.Pointer(&gid)), 231 } 232 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 233 return call.err 234 } 235 236 //go:nosplit 237 func syscall_setgroups(ngid, gid uintptr) (err uintptr) { 238 call := libcall{ 239 fn: uintptr(unsafe.Pointer(libc_setgroups)), 240 n: 2, 241 args: uintptr(unsafe.Pointer(&ngid)), 242 } 243 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 244 return call.err 245 } 246 247 //go:nosplit 248 func syscall_setsid() (pid, err uintptr) { 249 call := libcall{ 250 fn: uintptr(unsafe.Pointer(libc_setsid)), 251 n: 0, 252 args: uintptr(unsafe.Pointer(libc_setsid)), // it's unused but must be non-nil, otherwise crashes 253 } 254 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 255 return call.r1, call.err 256 } 257 258 //go:nosplit 259 func syscall_setuid(uid uintptr) (err uintptr) { 260 call := libcall{ 261 fn: uintptr(unsafe.Pointer(libc_setuid)), 262 n: 1, 263 args: uintptr(unsafe.Pointer(&uid)), 264 } 265 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 266 return call.err 267 } 268 269 //go:nosplit 270 func syscall_setpgid(pid, pgid uintptr) (err uintptr) { 271 call := libcall{ 272 fn: uintptr(unsafe.Pointer(libc_setpgid)), 273 n: 2, 274 args: uintptr(unsafe.Pointer(&pid)), 275 } 276 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 277 return call.err 278 } 279 280 // This is syscall.Syscall, it exists to satisfy some build dependency, 281 // but it doesn't work correctly. 282 // 283 // DO NOT USE! 284 // 285 // TODO(aram): make this panic once we stop calling fcntl(2) in net using it. 286 func syscall_syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 287 call := libcall{ 288 fn: uintptr(unsafe.Pointer(libc_syscall)), 289 n: 4, 290 args: uintptr(unsafe.Pointer(&trap)), 291 } 292 entersyscallblock(0) 293 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 294 exitsyscall(0) 295 return call.r1, call.r2, call.err 296 } 297 298 func syscall_wait4(pid uintptr, wstatus *uint32, options uintptr, rusage unsafe.Pointer) (wpid int, err uintptr) { 299 call := libcall{ 300 fn: uintptr(unsafe.Pointer(libc_wait4)), 301 n: 4, 302 args: uintptr(unsafe.Pointer(&pid)), 303 } 304 entersyscallblock(0) 305 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 306 exitsyscall(0) 307 return int(call.r1), call.err 308 } 309 310 //go:nosplit 311 func syscall_write(fd, buf, nbyte uintptr) (n, err uintptr) { 312 call := libcall{ 313 fn: uintptr(unsafe.Pointer(libc_write)), 314 n: 3, 315 args: uintptr(unsafe.Pointer(&fd)), 316 } 317 asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(&call)) 318 return call.r1, call.err 319 }