procStarted := map[uint64]bool{}
	for _, e := range data.Events {
		if e.Name == "proc start" {
			if procStarted[e.TID] == true {
				t.Errorf("proc started twice: %d", e.TID)
			}
			procStarted[e.TID] = true
		}
		if e.Name == "proc stop" {
			if procStarted[e.TID] == false {
				t.Errorf("proc stopped twice: %d", e.TID)
			}
			procStarted[e.TID] = false
		}
	}

	if parsedPodAddr == nil {
		return "", fmt.Errorf("failed to parse addr: %s", pod.Status.PodIP)
	}

	fs, err := procfs.NewFS("/host/proc")
	if err != nil {
		return "", fmt.Errorf("read procfs: %v", err)
	}
	procs, err := fs.AllProcs()
	if err != nil {
		return "", fmt.Errorf("read procs: %v", err)
	}
	oldest := uint64(math.MaxUint64)
	best := ""

	processIOReadBytesMD              = NewCounterMD(processIOReadBytes, "Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes")
	processIOWCharBytesMD             = NewCounterMD(processIOWCharBytes, "Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar")

}

// gets /proc/swaps's content as an input, returns true if swap is enabled.
func isSwapOnAccordingToProcSwaps(procSwapsContent []byte) bool {
	procSwapsContent = bytes.TrimSpace(procSwapsContent) // extra trailing \n
	procSwapsStr := string(procSwapsContent)
	procSwapsLines := strings.Split(procSwapsStr, "\n")

	// If there is more than one line (table headers) in /proc/swaps then swap is enabled

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

package event

// SchedReqs is a set of constraints on what the scheduling
// context must look like.
type SchedReqs struct {
	Thread    Constraint
	Proc      Constraint
	Goroutine Constraint
}

// Constraint represents a various presence requirements.
type Constraint uint8

const (
	MustNotHave Constraint = iota
	MayHave
	MustHave
)

func executable() (string, error) {
	var procfn string
	switch runtime.GOOS {
	default:
		return "", errors.New("Executable not implemented for " + runtime.GOOS)
	case "linux", "android":
		procfn = "/proc/self/exe"
	case "netbsd":
		procfn = "/proc/curproc/exe"
	}
	path, err := Readlink(procfn)

	// When the executable has been deleted then Readlink returns a
	// path appended with " (deleted)".

// limitations under the License.

package nodeagent

import "testing"

func TestOpenNetns(t *testing.T) {
	ns, err := OpenNetns("/proc/self/ns/net")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	// the inode for netns is proc dynamic, so it needs to be higher than
	// #define PROC_DYNAMIC_FIRST 0xF0000000U

	if ns.Inode() < 0xF0000000 {
		t.Fatalf("unexpected inode: %v", ns.Inode())
	}

	if err != nil {
		t.Skipf("starting test process: %v", err)
	}
	defer p.Kill()

	proc, err := FindProcess(p.Pid)
	if err != nil {
		t.Errorf("OS reported error for running process: %v", err)
	}
	err = proc.Signal(syscall.Signal(0))
	if err != nil {
		t.Errorf("OS reported error for running process: %v", err)
	}

)

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 {

-- 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