}

func getcwd() (string, error) {
	if !syscall.ImplementsGetwd {
		return "", nil
	}
	// Use the syscall to get the current working directory.
	// This is imperative for checking for OS thread state
	// after an unshare since os.Getwd might just check the
	// environment, or use some other mechanism.
	var buf [4096]byte
	n, err := syscall.Getcwd(buf[:])
	if err != nil {
		return "", err
	}

			defer c.tearDown()

			e := kubeAPIServerEnv{
				KubeHome:                     c.kubeHome,
				KubeAPIServerRunAsUser:       strconv.Itoa(os.Getuid()),
				EncryptionProviderConfigPath: filepath.Join(c.kubeHome, "encryption-provider-config.yaml"),
				EncryptionProviderConfig:     tc.encryptionProviderConfig,
			}

			c.mustInvokeFunc(
				e,

	//MOVW	R4, R4	// arg 1 pid
	MOVW	sig+0(FP), R5	// arg 2
	MOVV	$SYS_kill, R11
	SYSCALL
	RET

// func getpid() int
TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8
	MOVV	$SYS_getpid, R11
	SYSCALL
	MOVV	R4, ret+0(FP)
	RET

// func tgkill(tgid, tid, sig int)
TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24
	MOVV	tgid+0(FP), R4
	MOVV	tid+8(FP), R5
	MOVV	sig+16(FP), R6
	MOVV	$SYS_tgkill, R11
	SYSCALL
	RET

package main

import "os"

// Too small to trigger deadcode (currently)
var small = map[string]int{"foo": 1}

// Has side effects, which prevent deadcode
var effect = map[string]int{"foo": os.Getpid()}

// Large and side-effect free
var large = map[string]int{
	"11": 1, "12": 2, "13": 3, "14": 4, "15": 5, "16": 6, "17": 7, "18": 8, "19": 9, "110": 10,
	"21": 1, "22": 2, "23": 3, "24": 4, "25": 5, "26": 6, "27": 7, "28": 8, "29": 9, "210": 10,

    private final File pidFileInitScript = createPidFileInitScript(pidFile)

    List<String> getGradleArgs() {
        ["--init-script", pidFileInitScript.absolutePath]
    }

    String getPid() {
        pidFile.text
    }

    private static File createPidFile() {
        def pidFile = File.createTempFile("build-under-test", ".pid")
        pidFile.deleteOnExit()
        pidFile
    }

// license that can be found in the LICENSE file.

// Test that a program can survive SIGCHLD.

package main

import "syscall"

func main() {
	syscall.Kill(syscall.Getpid(), syscall.SIGCHLD)
	println("survived SIGCHLD")

	register("Segv", Segv)
}

var Sum int

func Segv() {
	c := make(chan bool)
	go func() {
		close(c)
		for i := 0; ; i++ {
			Sum += i
		}
	}()

	<-c

	syscall.Kill(syscall.Getpid(), syscall.SIGSEGV)

	// Wait for the OS to deliver the signal.
	select {}

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

package main

import (
	_ "unsafe"
)

//go:cgo_import_dynamic libc_getpid getpid "libc.so"
//go:cgo_import_dynamic libc_kill kill "libc.so"
//go:cgo_import_dynamic libc_close close "libc.so"
//go:cgo_import_dynamic libc_open open "libc.so"

//go:cgo_import_dynamic _ _ "libc.so"

func trampoline()

// license that can be found in the LICENSE file.

//go:build plan9

package os

import (
	"internal/itoa"
	"syscall"
)

func executable() (string, error) {
	fn := "/proc/" + itoa.Itoa(Getpid()) + "/text"
	f, err := Open(fn)
	if err != nil {
		return "", err
	}
	defer f.Close()
	return syscall.Fd2path(int(f.Fd()))

// license that can be found in the LICENSE file.

//go:build !linux
// +build !linux

package main

func gettid() int {
	return 0
}

func tidExists(tid int) (exists, supported bool, err error) {
	return false, false, nil
}

func getcwd() (string, error) {
	return "", nil
}

func unshareFs() error {
	return nil
}

func chdir(path string) error {
	return nil