Source file src/runtime/syscall_aix.go
1 // Copyright 2018 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 // This file handles some syscalls from the syscall package 10 // Especially, syscalls use during forkAndExecInChild which must not split the stack 11 12 //go:cgo_import_dynamic libc_chdir chdir "libc.a/shr_64.o" 13 //go:cgo_import_dynamic libc_chroot chroot "libc.a/shr_64.o" 14 //go:cgo_import_dynamic libc_dup2 dup2 "libc.a/shr_64.o" 15 //go:cgo_import_dynamic libc_execve execve "libc.a/shr_64.o" 16 //go:cgo_import_dynamic libc_fcntl fcntl "libc.a/shr_64.o" 17 //go:cgo_import_dynamic libc_fork fork "libc.a/shr_64.o" 18 //go:cgo_import_dynamic libc_ioctl ioctl "libc.a/shr_64.o" 19 //go:cgo_import_dynamic libc_setgid setgid "libc.a/shr_64.o" 20 //go:cgo_import_dynamic libc_setgroups setgroups "libc.a/shr_64.o" 21 //go:cgo_import_dynamic libc_setsid setsid "libc.a/shr_64.o" 22 //go:cgo_import_dynamic libc_setuid setuid "libc.a/shr_64.o" 23 //go:cgo_import_dynamic libc_setpgid setpgid "libc.a/shr_64.o" 24 25 //go:linkname libc_chdir libc_chdir 26 //go:linkname libc_chroot libc_chroot 27 //go:linkname libc_dup2 libc_dup2 28 //go:linkname libc_execve libc_execve 29 //go:linkname libc_fcntl libc_fcntl 30 //go:linkname libc_fork libc_fork 31 //go:linkname libc_ioctl libc_ioctl 32 //go:linkname libc_setgid libc_setgid 33 //go:linkname libc_setgroups libc_setgroups 34 //go:linkname libc_setsid libc_setsid 35 //go:linkname libc_setuid libc_setuid 36 //go:linkname libc_setpgid libc_setpgid 37 38 var ( 39 libc_chdir, 40 libc_chroot, 41 libc_dup2, 42 libc_execve, 43 libc_fcntl, 44 libc_fork, 45 libc_ioctl, 46 libc_setgid, 47 libc_setgroups, 48 libc_setsid, 49 libc_setuid, 50 libc_setpgid libFunc 51 ) 52 53 // In syscall_syscall6 and syscall_rawsyscall6, r2 is always 0 54 // as it's never used on AIX 55 // TODO: remove r2 from zsyscall_aix_$GOARCH.go 56 57 // Syscall is needed because some packages (like net) need it too. 58 // The best way is to return EINVAL and let Golang handles its failure 59 // If the syscall can't fail, this function can redirect it to a real syscall. 60 // 61 // This is exported via linkname to assembly in the syscall package. 62 // 63 //go:nosplit 64 //go:linkname syscall_Syscall 65 func syscall_Syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 66 return 0, 0, _EINVAL 67 } 68 69 // This is syscall.RawSyscall, it exists to satisfy some build dependency, 70 // but it doesn't work. 71 // 72 // This is exported via linkname to assembly in the syscall package. 73 // 74 //go:linkname syscall_RawSyscall 75 func syscall_RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 76 panic("RawSyscall not available on AIX") 77 } 78 79 // This is exported via linkname to assembly in the syscall package. 80 // 81 //go:nosplit 82 //go:cgo_unsafe_args 83 //go:linkname syscall_syscall6 84 func syscall_syscall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 85 c := libcall{ 86 fn: fn, 87 n: nargs, 88 args: uintptr(unsafe.Pointer(&a1)), 89 } 90 91 entersyscallblock() 92 asmcgocall(unsafe.Pointer(&asmsyscall6), unsafe.Pointer(&c)) 93 exitsyscall() 94 return c.r1, 0, c.err 95 } 96 97 // This is exported via linkname to assembly in the syscall package. 98 // 99 //go:nosplit 100 //go:cgo_unsafe_args 101 //go:linkname syscall_rawSyscall6 102 func syscall_rawSyscall6(fn, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 103 c := libcall{ 104 fn: fn, 105 n: nargs, 106 args: uintptr(unsafe.Pointer(&a1)), 107 } 108 109 asmcgocall(unsafe.Pointer(&asmsyscall6), unsafe.Pointer(&c)) 110 111 return c.r1, 0, c.err 112 } 113 114 //go:linkname syscall_chdir syscall.chdir 115 //go:nosplit 116 func syscall_chdir(path uintptr) (err uintptr) { 117 _, err = syscall1(&libc_chdir, path) 118 return 119 } 120 121 //go:linkname syscall_chroot1 syscall.chroot1 122 //go:nosplit 123 func syscall_chroot1(path uintptr) (err uintptr) { 124 _, err = syscall1(&libc_chroot, path) 125 return 126 } 127 128 // like close, but must not split stack, for fork. 129 //go:linkname syscall_close syscall.close 130 //go:nosplit 131 func syscall_close(fd int32) int32 { 132 _, err := syscall1(&libc_close, uintptr(fd)) 133 return int32(err) 134 } 135 136 //go:linkname syscall_dup2child syscall.dup2child 137 //go:nosplit 138 func syscall_dup2child(old, new uintptr) (val, err uintptr) { 139 val, err = syscall2(&libc_dup2, old, new) 140 return 141 } 142 143 //go:linkname syscall_execve syscall.execve 144 //go:nosplit 145 func syscall_execve(path, argv, envp uintptr) (err uintptr) { 146 _, err = syscall3(&libc_execve, path, argv, envp) 147 return 148 } 149 150 // like exit, but must not split stack, for fork. 151 //go:linkname syscall_exit syscall.exit 152 //go:nosplit 153 func syscall_exit(code uintptr) { 154 syscall1(&libc_exit, code) 155 } 156 157 //go:linkname syscall_fcntl1 syscall.fcntl1 158 //go:nosplit 159 func syscall_fcntl1(fd, cmd, arg uintptr) (val, err uintptr) { 160 val, err = syscall3(&libc_fcntl, fd, cmd, arg) 161 return 162 163 } 164 165 //go:linkname syscall_forkx syscall.forkx 166 //go:nosplit 167 func syscall_forkx(flags uintptr) (pid uintptr, err uintptr) { 168 pid, err = syscall1(&libc_fork, flags) 169 return 170 } 171 172 //go:linkname syscall_getpid syscall.getpid 173 //go:nosplit 174 func syscall_getpid() (pid, err uintptr) { 175 pid, err = syscall0(&libc_getpid) 176 return 177 } 178 179 //go:linkname syscall_ioctl syscall.ioctl 180 //go:nosplit 181 func syscall_ioctl(fd, req, arg uintptr) (err uintptr) { 182 _, err = syscall3(&libc_ioctl, fd, req, arg) 183 return 184 } 185 186 //go:linkname syscall_setgid syscall.setgid 187 //go:nosplit 188 func syscall_setgid(gid uintptr) (err uintptr) { 189 _, err = syscall1(&libc_setgid, gid) 190 return 191 } 192 193 //go:linkname syscall_setgroups1 syscall.setgroups1 194 //go:nosplit 195 func syscall_setgroups1(ngid, gid uintptr) (err uintptr) { 196 _, err = syscall2(&libc_setgroups, ngid, gid) 197 return 198 } 199 200 //go:linkname syscall_setsid syscall.setsid 201 //go:nosplit 202 func syscall_setsid() (pid, err uintptr) { 203 pid, err = syscall0(&libc_setsid) 204 return 205 } 206 207 //go:linkname syscall_setuid syscall.setuid 208 //go:nosplit 209 func syscall_setuid(uid uintptr) (err uintptr) { 210 _, err = syscall1(&libc_setuid, uid) 211 return 212 } 213 214 //go:linkname syscall_setpgid syscall.setpgid 215 //go:nosplit 216 func syscall_setpgid(pid, pgid uintptr) (err uintptr) { 217 _, err = syscall2(&libc_setpgid, pid, pgid) 218 return 219 } 220 221 //go:linkname syscall_write1 syscall.write1 222 //go:nosplit 223 func syscall_write1(fd, buf, nbyte uintptr) (n, err uintptr) { 224 n, err = syscall3(&libc_write, fd, buf, nbyte) 225 return 226 } 227