return pkg, nil
	})
}

var errCorrupt = errors.New("corrupt index")

// protect marks the start of a large section of code that accesses the index.
// It should be used as:
//
//	defer unprotect(protect, &err)
//
// It should not be used for trivial accesses which would be
// dwarfed by the overhead of the defer.
func protect() bool {
	return debug.SetPanicOnFault(true)
}

var isTest = false

	SigStackCallback();

	// Disable signal stack and protect it so we can detect reuse.
	if (ost.ss_flags & SS_DISABLE) {
		// Darwin libsystem has a bug where it checks ss_size
		// even if SS_DISABLE is set. (The kernel gets it right.)
		ost.ss_size = CSIGSTKSZ;
	}
	if (sigaltstack(&ost, NULL) < 0) {
		perror("sigaltstack restore failed");
		abort();
	}
	mprotect(base, CSIGSTKSZ, PROT_NONE);
	return NULL;
}

	// So, call mprotect to change permissions.
	// Note that sysMap is always called with a non-nil pointer
	// since it transitions a Reserved memory region to Prepared,
	// so mprotect is always possible.
	_, err := mprotect(v, n, _PROT_READ|_PROT_WRITE)
	if err == _ENOMEM {
		throw("runtime: out of memory")
	}
	if err != 0 {
		print("runtime: mprotect(", v, ", ", n, ") returned ", err, "\n")

//go:cgo_import_dynamic malloc_zones malloc_zones ""
//go:cgo_import_dynamic memcpy memcpy ""
//go:cgo_import_dynamic memset_pattern16 memset_pattern16 ""
//go:cgo_import_dynamic mkdir mkdir ""
//go:cgo_import_dynamic mprotect mprotect ""
//go:cgo_import_dynamic open open ""
//go:cgo_import_dynamic pipe pipe ""
//go:cgo_import_dynamic posix_openpt posix_openpt ""
//go:cgo_import_dynamic posix_spawn posix_spawn ""

//go:cgo_import_dynamic malloc_zones malloc_zones ""
//go:cgo_import_dynamic memcpy memcpy ""
//go:cgo_import_dynamic memset_pattern16 memset_pattern16 ""
//go:cgo_import_dynamic mkdir mkdir ""
//go:cgo_import_dynamic mprotect mprotect ""
//go:cgo_import_dynamic open open ""
//go:cgo_import_dynamic pipe pipe ""
//go:cgo_import_dynamic posix_openpt posix_openpt ""
//go:cgo_import_dynamic posix_spawn posix_spawn ""

	if err != nil {
		t.Fatalf("mmap failed %s", err)
	}
	defer syscall.Munmap(b)
	err = syscall.Mprotect(b[pagesize:], syscall.PROT_NONE)
	if err != nil {
		t.Fatalf("mprotect high failed %s\n", err)
	}

	// This should not fault.
	a := (*uint32)(unsafe.Pointer(&b[pagesize-4]))
	atomic.StoreUint32(a, 1)
	if x := atomic.LoadUint32(a); x != 1 {

	const pageSize = 4 << 10
	data, err := syscall.Mmap(0, 0, 2*pageSize, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE)
	if err != nil {
		panic(err)
	}
	if err := syscall.Mprotect(data[pageSize:], syscall.PROT_NONE); err != nil {
		panic(err)
	}
	for i := 0; i < pageSize; i++ {
		sha1.Sum(data[pageSize-i : pageSize])
	}

// Putting the key protect us from returning a 404 response instead of a 503.
// It is especially important for controllers like GC and NS since they act on 404s.
//
// The presence of the key is checked in the NotFoundHandler (staging/src/k8s.io/apiserver/pkg/util/notfoundhandler/not_found_handler.go)
//

	// could create a mapping that ends up in this hole otherwise,
	// invalidating the test.
	hole := data[len(data)/2 : 3*(len(data)/4)]
	if err := syscall.Mprotect(hole, syscall.PROT_NONE); err != nil {
		log.Fatalf("mprotect: %v", err)
	}

	// Check that memcopy returns the actual amount copied
	// before the fault.
	const offset = 5
	n, err := memcopy(data[offset:], make([]byte, len(data)))

)

type MemoryBasicInformation struct {
	BaseAddress       uintptr
	AllocationBase    uintptr
	AllocationProtect uint32
	PartitionId       uint16
	RegionSize        uintptr
	State             uint32
	Protect           uint32
	Type              uint32