if runtime.GOOS == "windows" {
		return
	}

	const tempPrefix = "test.kubeadm.runtime.isExistingSocket."
	tests := []struct {
		name string
		proc func(*testing.T)
	}{
		{
			name: "Valid domain socket is detected as such",
			proc: func(t *testing.T) {
				tmpFile, err := os.CreateTemp("", tempPrefix)
				if err != nil {
					t.Fatalf("unexpected error by TempFile: %v", err)
				}

    .386
    .model    flat

PUBLIC    _sum
_TEXT     SEGMENT
_sum    PROC
    mov    eax, DWORD PTR 4[esp]
    add    eax, DWORD PTR 8[esp]
    ret    0
_sum    ENDP
_TEXT   ENDS

// FirstQuota is the quota ID we start with.
// XXXXXXX Need a better way of doing this...
var FirstQuota QuotaID = 1048577

// MountsFile is the location of the system mount data
var MountsFile = "/proc/self/mounts"

// MountParseRegexp parses out /proc/sys/self/mounts
var MountParseRegexp = regexp.MustCompilePOSIX("^([^ ]*)[ \t]*([^ ]*)[ \t]*([^ ]*)") // Ignore options etc.

// LinuxVolumeQuotaProvider returns an appropriate quota applier

		}

		fmt.Printf("leaked parent file. fdtest.Exists(%d) got true want false\n", fd)

		fdfile := fmt.Sprintf("/proc/self/fd/%d", fd)
		link, err := os.Readlink(fdfile)
		fmt.Printf("readlink(%q) = %q, %v\n", fdfile, link, err)

		var args []string
		switch runtime.GOOS {
		case "plan9":
			args = []string{fmt.Sprintf("/proc/%d/fd", os.Getpid())}
		case "aix", "solaris", "illumos":
			args = []string{fmt.Sprint(os.Getpid())}
		default:

)

func gettid() int {
	return syscall.Gettid()
}

func tidExists(tid int) (exists, supported bool, err error) {
	// Open the magic proc status file for reading with the syscall package.
	// We want to identify certain valid errors very precisely.
	statusFile := fmt.Sprintf("/proc/self/task/%d/status", tid)
	fd, err := syscall.Open(statusFile, syscall.O_RDONLY, 0)
	if errno, ok := err.(syscall.Errno); ok {

	}
}

// block indicates that the goroutine has stopped executing on a proc -- specifically,
// it blocked for some reason.
func (gs *gState[R]) block(ts trace.Time, stack trace.Stack, reason string, ctx *traceContext) {
	gs.startBlockReason = reason
	gs.stop(ts, stack, ctx)
}

// stop indicates that the goroutine has stopped executing on a proc.
func (gs *gState[R]) stop(ts trace.Time, stack trace.Stack, ctx *traceContext) {

-- expect --
FAILURE ".*expected a proc but didn't have one.*"
-- trace --
Trace Go1.22
EventBatch gen=1 m=0 time=0 size=34
GoCreateSyscall dt=1 new_g=4
ProcStatus dt=1 p=0 pstatus=2
ProcStart dt=1 p=0 p_seq=1
GoSyscallEndBlocked dt=1
GoStart dt=1 g=4 g_seq=1
GoSyscallBegin dt=1 p_seq=2 stack=0
GoDestroySyscall dt=1
GoCreateSyscall dt=1 new_g=4
GoSyscallEnd dt=1
GoSyscallBegin dt=1 p_seq=3 stack=0
GoDestroySyscall dt=1

	"github.com/opencontainers/selinux/go-selinux"
	"golang.org/x/sys/unix"
	"k8s.io/klog/v2"
	"k8s.io/mount-utils"
	utilpath "k8s.io/utils/path"
)

const (
	// Location of the mountinfo file
	procMountInfoPath = "/proc/self/mountinfo"
)

// HostUtil implements HostUtils for Linux platforms.
type HostUtil struct {
}

// NewHostUtil returns a struct that implements the HostUtils interface on
// linux platforms

-- expect --
FAILURE "expected a proc but didn't have one"
-- trace --
Trace Go1.22
EventBatch gen=1 m=0 time=0 size=5
Frequency freq=15625000
EventBatch gen=1 m=0 time=0 size=5
GoCreate dt=0 new_g=1 new_stack=0 stack=0

// 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()))