}
}

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

	result := make(map[string]string)

	mountInfo, err := os.Open("/proc/self/mountinfo")
	if err != nil {
		return nil, err
	}
	defer mountInfo.Close()

	scanner := bufio.NewScanner(mountInfo)
	for scanner.Scan() {
		s := strings.Split(scanner.Text(), " ")
		if len(s) != 11 {
			return nil, errors.New("unsupported /proc/self/mountinfo format")
		}
		result[s[2]] = s[9]
	}

	availableProcs := make([]*proc, len(allProcs))
	for i := range allProcs {
		availableProcs[i] = &allProcs[i]
	}
	for {
	pidLoop:
		for i := 0; i < len(availableProcs); i++ {
			proc := availableProcs[i]

			for len(proc.events) == 0 {
				// Call loadBatch in a loop because sometimes batches are empty
				evs, err := p.loadBatch(proc.pid, proc.buf[:0])
				proc.buf = evs[:0]
				if err == io.EOF {

		sb.WriteByte(byte(b))
	}
	major, minor, _, ok := parseRelease(sb.String())
	return ok && (major > 4 || major == 4 && minor >= 11)
}

func doinit() {
	if err := readHWCAP(); err != nil {
		// We failed to read /proc/self/auxv. This can happen if the binary has
		// been given extra capabilities(7) with /bin/setcap.
		//
		// When this happens, we have two options. If the Linux kernel is new

			g.ranges[r] = activeRange{ctx.startTime, ev.Stack()}
		}
	case trace.EventRangeEnd:
		// Emit proc-based ranges.
		ar := g.ranges[r]
		ctx.Slice(traceviewer.SliceEvent{
			Name:     r.Name,
			Ts:       ctx.elapsed(ar.time),
			Dur:      ev.Time().Sub(ar.time),
			Resource: uint64(r.Scope.Proc()),
			Stack:    ctx.Stack(viewerFrames(ar.stack)),
			EndStack: ctx.Stack(viewerFrames(ev.Stack())),
		})

	if major > 4 || (major == 4 && minor >= 1) {
		size = 32
	}

	var max uint = 1<<size - 1
	if uint(n) > max {
		n = int(max)
	}
	return n
}

func maxListenerBacklog() int {
	fd, err := open("/proc/sys/net/core/somaxconn")
	if err != nil {
		return syscall.SOMAXCONN
	}
	defer fd.close()
	l, ok := fd.readLine()
	if !ok {
		return syscall.SOMAXCONN
	}
	f := getFields(l)
	n, _, ok := dtoi(f[0])

			serviceCidr: "10.96.0.0/16,fda9:d324:354d:1::/112",
			expStr:      []string{"FileContent--proc-sys-net-ipv4-ip_forward", "FileContent--proc-sys-net-ipv6-conf-default-forwarding"},
		},
		{
			testName:    "single stack ipv4",
			PodSubnet:   "10.244.0.0/16",
			serviceCidr: "10.96.0.0/16",
			expStr:      []string{"FileContent--proc-sys-net-ipv4-ip_forward"},
		},
		{
			testName:    "single stack ipv6",