SYS_GETTIMEOFDAY           = 169
	SYS_SETTIMEOFDAY           = 170
	SYS_ADJTIMEX               = 171
	SYS_GETPID                 = 172
	SYS_GETPPID                = 173
	SYS_GETUID                 = 174
	SYS_GETEUID                = 175
	SYS_GETGID                 = 176
	SYS_GETEGID                = 177
	SYS_GETTID                 = 178
	SYS_SYSINFO                = 179
	SYS_MQ_OPEN                = 180

	SYS_GETTIMEOFDAY           = 169
	SYS_SETTIMEOFDAY           = 170
	SYS_ADJTIMEX               = 171
	SYS_GETPID                 = 172
	SYS_GETPPID                = 173
	SYS_GETUID                 = 174
	SYS_GETEUID                = 175
	SYS_GETGID                 = 176
	SYS_GETEGID                = 177
	SYS_GETTID                 = 178
	SYS_SYSINFO                = 179
	SYS_MQ_OPEN                = 180

		}

		// Signal self if parent is already dead. This might cause a
		// duplicate signal in rare cases, but it won't matter when
		// using SIGKILL.
		r1, _, _ = RawSyscall(SYS_GETPPID, 0, 0, 0)
		if r1 != ppid {
			upid, _, _ = RawSyscall(SYS_GETPID, 0, 0, 0)
			_, _, err1 = RawSyscall(SYS_KILL, upid, uintptr(sys.Pdeathsig), 0)
			if err1 != 0 {
				goto childerror
			}
		}
	}

		// Place child in process group.
		_, _, err1 = RawSyscall(SYS_SETPGID, 0, uintptr(sys.Pgid), 0)
		if err1 != 0 {
			goto childerror
		}
	}

	if sys.Foreground {
		// This should really be pid_t, however _C_int (aka int32) is
		// generally equivalent.
		pgrp = _C_int(sys.Pgid)
		if pgrp == 0 {
			r1, _, err1 = RawSyscall(SYS_GETPID, 0, 0, 0)
			if err1 != 0 {
				goto childerror
			}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build linux && !386 && !arm

package syscall

const (
	sys_GETEUID = SYS_GETEUID

	sys_SETGID = SYS_SETGID
	sys_SETUID = SYS_SETUID

	sys_SETREGID = SYS_SETREGID
	sys_SETREUID = SYS_SETREUID

	sys_SETRESGID = SYS_SETRESGID
	sys_SETRESUID = SYS_SETRESUID

package syscall

import (
	"unsafe"
)

var (
	RawSyscallNoError = rawSyscallNoError
	ForceClone3       = &forceClone3
	Prlimit           = prlimit
)

const (
	Sys_GETEUID = sys_GETEUID
)

func Tcgetpgrp(fd int) (pgid int32, err error) {
	_, _, errno := Syscall6(SYS_IOCTL, uintptr(fd), uintptr(TIOCGPGRP), uintptr(unsafe.Pointer(&pgid)), 0, 0, 0)
	if errno != 0 {
		return -1, errno
	}

	// SIGILL is received.
	// If you get a SIGILL here, you have the wrong kernel.

	// Save argc and argv (syscall will clobber at least R0).
	MOVM.DB.W [R0-R1], (R13)

	// do an EABI syscall
	MOVW	$20, R7 // sys_getpid
	SWI	$0 // this will trigger SIGILL on OABI systems

	MOVM.IA.W (R13), [R0-R1]

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build linux && (386 || arm)

package syscall

const (
	sys_GETEUID = SYS_GETEUID32

	sys_SETGID = SYS_SETGID32
	sys_SETUID = SYS_SETUID32

	sys_SETREGID = SYS_SETREGID32
	sys_SETREUID = SYS_SETREUID32

	sys_SETRESGID = SYS_SETRESGID32
	sys_SETRESUID = SYS_SETRESUID32

	ADDU	$24, R29, R4
	MOVW	$0, R5
	MOVW	$SYS_nanosleep, R2
	SYSCALL
	RET

TEXT runtime·gettid(SB),NOSPLIT,$0-4
	MOVW	$SYS_gettid, R2
	SYSCALL
	MOVW	R2, ret+0(FP)
	RET

TEXT runtime·raise(SB),NOSPLIT,$0-4
	MOVW	$SYS_getpid, R2
	SYSCALL
	MOVW	R2, R16
	MOVW	$SYS_gettid, R2
	SYSCALL
	MOVW	R2, R5	// arg 2 tid
	MOVW	R16, R4	// arg 1 pid
	MOVW	sig+0(FP), R6	// arg 3
	MOVW	$SYS_tgkill, R2

#include "go_tls.h"
#include "textflag.h"

#define CLOCK_REALTIME		0
#define CLOCK_MONOTONIC		4

#define SYS_exit		1
#define SYS_read		3
#define SYS_write		4
#define SYS_open		5
#define SYS_close		6
#define SYS_getpid		20
#define SYS_kill		37
#define SYS_sigaltstack		53
#define SYS_munmap		73
#define SYS_madvise		75
#define SYS_setitimer		83
#define SYS_fcntl		92
#define SYS_sysarch		165
#define SYS___sysctl		202