github.com/lzhfromustc/gofuzz@v0.0.0-20211116160056-151b3108bbd1/runtime/sys_openbsd2.go (about) 1 // Copyright 2020 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 // +build openbsd,amd64 openbsd,arm64 6 7 package runtime 8 9 import "unsafe" 10 11 // This is exported via linkname to assembly in runtime/cgo. 12 //go:linkname exit 13 //go:nosplit 14 //go:cgo_unsafe_args 15 func exit(code int32) { 16 libcCall(unsafe.Pointer(funcPC(exit_trampoline)), unsafe.Pointer(&code)) 17 } 18 func exit_trampoline() 19 20 //go:nosplit 21 //go:cgo_unsafe_args 22 func getthrid() (tid int32) { 23 libcCall(unsafe.Pointer(funcPC(getthrid_trampoline)), unsafe.Pointer(&tid)) 24 return 25 } 26 func getthrid_trampoline() 27 28 //go:nosplit 29 //go:cgo_unsafe_args 30 func raiseproc(sig uint32) { 31 libcCall(unsafe.Pointer(funcPC(raiseproc_trampoline)), unsafe.Pointer(&sig)) 32 } 33 func raiseproc_trampoline() 34 35 //go:nosplit 36 //go:cgo_unsafe_args 37 func thrkill(tid int32, sig int) { 38 libcCall(unsafe.Pointer(funcPC(thrkill_trampoline)), unsafe.Pointer(&tid)) 39 } 40 func thrkill_trampoline() 41 42 // mmap is used to do low-level memory allocation via mmap. Don't allow stack 43 // splits, since this function (used by sysAlloc) is called in a lot of low-level 44 // parts of the runtime and callers often assume it won't acquire any locks. 45 // go:nosplit 46 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) { 47 args := struct { 48 addr unsafe.Pointer 49 n uintptr 50 prot, flags, fd int32 51 off uint32 52 ret1 unsafe.Pointer 53 ret2 int 54 }{addr, n, prot, flags, fd, off, nil, 0} 55 libcCall(unsafe.Pointer(funcPC(mmap_trampoline)), unsafe.Pointer(&args)) 56 return args.ret1, args.ret2 57 } 58 func mmap_trampoline() 59 60 //go:nosplit 61 //go:cgo_unsafe_args 62 func munmap(addr unsafe.Pointer, n uintptr) { 63 libcCall(unsafe.Pointer(funcPC(munmap_trampoline)), unsafe.Pointer(&addr)) 64 } 65 func munmap_trampoline() 66 67 //go:nosplit 68 //go:cgo_unsafe_args 69 func madvise(addr unsafe.Pointer, n uintptr, flags int32) { 70 libcCall(unsafe.Pointer(funcPC(madvise_trampoline)), unsafe.Pointer(&addr)) 71 } 72 func madvise_trampoline() 73 74 //go:nosplit 75 //go:cgo_unsafe_args 76 func open(name *byte, mode, perm int32) (ret int32) { 77 return libcCall(unsafe.Pointer(funcPC(open_trampoline)), unsafe.Pointer(&name)) 78 } 79 func open_trampoline() 80 81 //go:nosplit 82 //go:cgo_unsafe_args 83 func closefd(fd int32) int32 { 84 return libcCall(unsafe.Pointer(funcPC(close_trampoline)), unsafe.Pointer(&fd)) 85 } 86 func close_trampoline() 87 88 //go:nosplit 89 //go:cgo_unsafe_args 90 func read(fd int32, p unsafe.Pointer, n int32) int32 { 91 return libcCall(unsafe.Pointer(funcPC(read_trampoline)), unsafe.Pointer(&fd)) 92 } 93 func read_trampoline() 94 95 //go:nosplit 96 //go:cgo_unsafe_args 97 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 { 98 return libcCall(unsafe.Pointer(funcPC(write_trampoline)), unsafe.Pointer(&fd)) 99 } 100 func write_trampoline() 101 102 func pipe() (r, w int32, errno int32) { 103 return pipe2(0) 104 } 105 106 func pipe2(flags int32) (r, w int32, errno int32) { 107 var p [2]int32 108 args := struct { 109 p unsafe.Pointer 110 flags int32 111 }{noescape(unsafe.Pointer(&p)), flags} 112 errno = libcCall(unsafe.Pointer(funcPC(pipe2_trampoline)), unsafe.Pointer(&args)) 113 return p[0], p[1], errno 114 } 115 func pipe2_trampoline() 116 117 //go:nosplit 118 //go:cgo_unsafe_args 119 func setitimer(mode int32, new, old *itimerval) { 120 libcCall(unsafe.Pointer(funcPC(setitimer_trampoline)), unsafe.Pointer(&mode)) 121 } 122 func setitimer_trampoline() 123 124 //go:nosplit 125 //go:cgo_unsafe_args 126 func usleep(usec uint32) { 127 libcCall(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec)) 128 } 129 func usleep_trampoline() 130 131 //go:nosplit 132 //go:cgo_unsafe_args 133 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32 { 134 return libcCall(unsafe.Pointer(funcPC(sysctl_trampoline)), unsafe.Pointer(&mib)) 135 } 136 func sysctl_trampoline() 137 138 //go:nosplit 139 //go:cgo_unsafe_args 140 func fcntl(fd, cmd, arg int32) int32 { 141 return libcCall(unsafe.Pointer(funcPC(fcntl_trampoline)), unsafe.Pointer(&fd)) 142 } 143 func fcntl_trampoline() 144 145 //go:nosplit 146 func nanotime1() int64 { 147 var ts timespec 148 args := struct { 149 clock_id int32 150 tp unsafe.Pointer 151 }{_CLOCK_MONOTONIC, unsafe.Pointer(&ts)} 152 libcCall(unsafe.Pointer(funcPC(clock_gettime_trampoline)), unsafe.Pointer(&args)) 153 return ts.tv_sec*1e9 + int64(ts.tv_nsec) 154 } 155 func clock_gettime_trampoline() 156 157 //go:nosplit 158 func walltime1() (int64, int32) { 159 var ts timespec 160 args := struct { 161 clock_id int32 162 tp unsafe.Pointer 163 }{_CLOCK_REALTIME, unsafe.Pointer(&ts)} 164 libcCall(unsafe.Pointer(funcPC(clock_gettime_trampoline)), unsafe.Pointer(&args)) 165 return ts.tv_sec, int32(ts.tv_nsec) 166 } 167 168 //go:nosplit 169 //go:cgo_unsafe_args 170 func kqueue() int32 { 171 return libcCall(unsafe.Pointer(funcPC(kqueue_trampoline)), nil) 172 } 173 func kqueue_trampoline() 174 175 //go:nosplit 176 //go:cgo_unsafe_args 177 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 { 178 return libcCall(unsafe.Pointer(funcPC(kevent_trampoline)), unsafe.Pointer(&kq)) 179 } 180 func kevent_trampoline() 181 182 //go:nosplit 183 //go:cgo_unsafe_args 184 func sigaction(sig uint32, new *sigactiont, old *sigactiont) { 185 libcCall(unsafe.Pointer(funcPC(sigaction_trampoline)), unsafe.Pointer(&sig)) 186 } 187 func sigaction_trampoline() 188 189 //go:nosplit 190 //go:cgo_unsafe_args 191 func sigprocmask(how uint32, new *sigset, old *sigset) { 192 libcCall(unsafe.Pointer(funcPC(sigprocmask_trampoline)), unsafe.Pointer(&how)) 193 } 194 func sigprocmask_trampoline() 195 196 //go:nosplit 197 //go:cgo_unsafe_args 198 func sigaltstack(new *stackt, old *stackt) { 199 libcCall(unsafe.Pointer(funcPC(sigaltstack_trampoline)), unsafe.Pointer(&new)) 200 } 201 func sigaltstack_trampoline() 202 203 // Not used on OpenBSD, but must be defined. 204 func exitThread(wait *uint32) { 205 } 206 207 //go:nosplit 208 func closeonexec(fd int32) { 209 fcntl(fd, _F_SETFD, _FD_CLOEXEC) 210 } 211 212 //go:nosplit 213 func setNonblock(fd int32) { 214 flags := fcntl(fd, _F_GETFL, 0) 215 fcntl(fd, _F_SETFL, flags|_O_NONBLOCK) 216 } 217 218 // Tell the linker that the libc_* functions are to be found 219 // in a system library, with the libc_ prefix missing. 220 221 //go:cgo_import_dynamic libc_errno __errno "libc.so" 222 //go:cgo_import_dynamic libc_exit exit "libc.so" 223 //go:cgo_import_dynamic libc_getthrid getthrid "libc.so" 224 //go:cgo_import_dynamic libc_sched_yield sched_yield "libc.so" 225 //go:cgo_import_dynamic libc_thrkill thrkill "libc.so" 226 227 //go:cgo_import_dynamic libc_mmap mmap "libc.so" 228 //go:cgo_import_dynamic libc_munmap munmap "libc.so" 229 //go:cgo_import_dynamic libc_madvise madvise "libc.so" 230 231 //go:cgo_import_dynamic libc_open open "libc.so" 232 //go:cgo_import_dynamic libc_close close "libc.so" 233 //go:cgo_import_dynamic libc_read read "libc.so" 234 //go:cgo_import_dynamic libc_write write "libc.so" 235 //go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so" 236 237 //go:cgo_import_dynamic libc_clock_gettime clock_gettime "libc.so" 238 //go:cgo_import_dynamic libc_setitimer setitimer "libc.so" 239 //go:cgo_import_dynamic libc_usleep usleep "libc.so" 240 //go:cgo_import_dynamic libc_sysctl sysctl "libc.so" 241 //go:cgo_import_dynamic libc_fcntl fcntl "libc.so" 242 //go:cgo_import_dynamic libc_getpid getpid "libc.so" 243 //go:cgo_import_dynamic libc_kill kill "libc.so" 244 //go:cgo_import_dynamic libc_kqueue kqueue "libc.so" 245 //go:cgo_import_dynamic libc_kevent kevent "libc.so" 246 247 //go:cgo_import_dynamic libc_sigaction sigaction "libc.so" 248 //go:cgo_import_dynamic libc_sigaltstack sigaltstack "libc.so" 249 250 //go:cgo_import_dynamic _ _ "libc.so"