}

func sysctlNodes(mib []_C_int) (nodes []Sysctlnode, err error) {
	var olen uintptr

	// Get a list of all sysctl nodes below the given MIB by performing
	// a sysctl for the given MIB with CTL_QUERY appended.
	mib = append(mib, CTL_QUERY)
	qnode := Sysctlnode{Flags: SYSCTL_VERS_1}
	qp := (*byte)(unsafe.Pointer(&qnode))
	sz := unsafe.Sizeof(qnode)
	if err = sysctl(mib, nil, &olen, qp, sz); err != nil {

//go:linkname syscall_syscall6 syscall.syscall6

func sysctl(mib []uint32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
	_, _, errno := syscall_syscall6(libc_sysctl_trampoline_addr, uintptr(unsafe.Pointer(&mib[0])), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
	if errno != 0 {

	"syscall"
	"unsafe"
)

const (
	_CTL_KERN = 1

	_KERN_ARND = 81
)

func GetEntropy(p []byte) error {
	mib := [2]uint32{_CTL_KERN, _KERN_ARND}
	n := uintptr(len(p))
	_, _, errno := syscall.Syscall6(
		syscall.SYS___SYSCTL,
		uintptr(unsafe.Pointer(&mib[0])),
		uintptr(len(mib)),
		uintptr(unsafe.Pointer(&p[0])), // olddata
		uintptr(unsafe.Pointer(&n)),    // &oldlen
		uintptr(unsafe.Pointer(nil)),   // newdata

on 16 drive MinIO deployment. If you use eight data and eight parity drives, the file space usage will be approximately twice, i.e. 100 MiB
file will take 200 MiB space. But, if you use ten data and six parity drives, same 100 MiB file takes around 160 MiB. If you use 14 data and
two parity drives, 100 MiB file takes only approximately 114 MiB.

        1024L**1 + 1      | '1 KiB'
        1024L**1 * 987    | '987 KiB'
        1024L**2 - 1      | '1023.9 KiB'

        1024L**2          | '1 MiB'
        1024L**2 + 1      | '1 MiB'
        1024L**2 * 654    | '654 MiB'
        1024L**3 - 1      | '1023.9 MiB'

        1024L**3          | '1 GiB'
        1024L**3 + 1      | '1 GiB'
        1024L**3 * 321    | '321 GiB'
        1024L**4 - 1      | '1023.9 GiB'

)

func sysctlInt(mib []uint32) (int32, bool) {
	var out int32
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], uint32(len(mib)), (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret < 0 {
		return 0, false
	}
	return out, true
}

func sysctlUint64(mib []uint32) (uint64, bool) {
	var out uint64
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], uint32(len(mib)), (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)

func getncpu() int32 {
	mib := [2]uint32{_CTL_HW, _HW_NCPU}
	out := uint32(0)
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret >= 0 {
		return int32(out)
	}
	return 1
}

func getPageSize() uintptr {
	mib := [2]uint32{_CTL_HW, _HW_PAGESIZE}
	out := uint32(0)
	nout := unsafe.Sizeof(out)

			t.Skip("fallocate is not supported")
		}
		if err == syscall.EINTR {
			continue // try again
		}
		if err != nil {
			t.Fatalf("fallocate failed: %v", err)
		}
		break
	}

	// Mmap 1 MiB initially, and grow to 2 and 3 MiB.
	// Check if the file size and disk usage is expected.
	for _, sz := range []int64{1 << 20, 2 << 20, 3 << 20} {
		err = out.Mmap(uint64(sz))
		if err != nil {
			t.Fatalf("Mmap failed: %v", err)
		}

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

//go:build darwin || dragonfly || freebsd || netbsd || openbsd

package route

import _ "unsafe" // for linkname

//go:linkname sysctl syscall.sysctl

				UpperBound: 10 << 20,
				LowerBound: 1 << 20,
			},
			want: true,
		},
		{
			// 2KiB < 1 MiB -> out of range from left
			objSize: 2 << 10,
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,
				LowerBound: 1 << 20,
			},
			want: false,
		},
		{
			// 11MiB > 10 MiB -> out of range from right
			objSize: 11 << 20,
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,