Black Lives Matter. Support the Equal Justice Initiative.

Source file src/runtime/syscall_aix.go

Documentation: runtime

     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  

View as plain text