"sync"

const (

	SYS_FSTAT_FREEBSD12         = 551 // { int fstat(int fd, _Out_ struct stat *sb); }

	SYS_FSTATAT_FREEBSD12       = 552 // { int fstatat(int fd, _In_z_ char *path, \

	SYS_GETDIRENTRIES_FREEBSD12 = 554 // { ssize_t getdirentries(int fd, \

	SYS_STATFS_FREEBSD12        = 555 // { int statfs(_In_z_ char *path, \

	SYS_FSTATFS_FREEBSD12       = 556 // { int fstatfs(int fd, \

	SYS_GETFSSTAT_FREEBSD12     = 557 // { int getfsstat( \

	SYS_MKNODAT_FREEBSD12       = 559 // { int mknodat(int fd, _In_z_ char *path, \

)

// See https://www.freebsd.org/doc/en_US.ISO8859-1/books/porters-handbook/versions.html.

var (

	osreldateOnce sync.Once

	osreldate     uint32

)

// INO64_FIRST from /usr/src/lib/libc/sys/compat-ino64.h

const _ino64First = 1200031

func supportsABI(ver uint32) bool {

	osreldateOnce.Do(func() { osreldate, _ = SysctlUint32("kern.osreldate") })

	return osreldate >= ver

}

func direntIno(buf []byte) (uint64, bool) {

	return readInt(buf, unsafe.Offsetof(Dirent{}.Fileno), unsafe.Sizeof(Dirent{}.Fileno))

}

func direntReclen(buf []byte) (uint64, bool) {

	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))

}

func direntNamlen(buf []byte) (uint64, bool) {

	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))

}

	var (

		_p0          unsafe.Pointer

		bufsize      uintptr

		oldBuf       []statfs_freebsd11_t

		needsConvert bool

	)

		if supportsABI(_ino64First) {

			_p0 = unsafe.Pointer(&buf[0])

			bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))

		} else {

			n := len(buf)

			oldBuf = make([]statfs_freebsd11_t, n)

			_p0 = unsafe.Pointer(&oldBuf[0])

			bufsize = unsafe.Sizeof(statfs_freebsd11_t{}) * uintptr(n)

			needsConvert = true

		}

	var sysno uintptr = SYS_GETFSSTAT

	if supportsABI(_ino64First) {

		sysno = SYS_GETFSSTAT_FREEBSD12

	}

	r0, _, e1 := Syscall(sysno, uintptr(_p0), bufsize, uintptr(flags))

	if e1 == 0 && needsConvert {

		for i := range oldBuf {

			buf[i].convertFrom(&oldBuf[i])

		}

	}

//sys   sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) = SYS___SYSCTL

func Stat(path string, st *Stat_t) (err error) {

	var oldStat stat_freebsd11_t

	if supportsABI(_ino64First) {

		return fstatat_freebsd12(AT_FDCWD, path, st, 0)

	}

	err = stat(path, &oldStat)

	if err != nil {

		return err

	}

	st.convertFrom(&oldStat)

	return nil

}

func Lstat(path string, st *Stat_t) (err error) {

	var oldStat stat_freebsd11_t

	if supportsABI(_ino64First) {

		return fstatat_freebsd12(AT_FDCWD, path, st, AT_SYMLINK_NOFOLLOW)

	}

	err = lstat(path, &oldStat)

	if err != nil {

		return err

	}

	st.convertFrom(&oldStat)

	return nil

}

func Fstat(fd int, st *Stat_t) (err error) {

	var oldStat stat_freebsd11_t

	if supportsABI(_ino64First) {

		return fstat_freebsd12(fd, st)

	}

	err = fstat(fd, &oldStat)

	if err != nil {

		return err

	}

	st.convertFrom(&oldStat)

	return nil

}

func Fstatat(fd int, path string, st *Stat_t, flags int) (err error) {

	var oldStat stat_freebsd11_t

	if supportsABI(_ino64First) {

		return fstatat_freebsd12(fd, path, st, flags)

	}

	err = fstatat(fd, path, &oldStat, flags)

	if err != nil {

		return err

	}

	st.convertFrom(&oldStat)

	return nil

}

func Statfs(path string, st *Statfs_t) (err error) {

	var oldStatfs statfs_freebsd11_t

	if supportsABI(_ino64First) {

		return statfs_freebsd12(path, st)

	}

	err = statfs(path, &oldStatfs)

	if err != nil {

		return err

	}

	st.convertFrom(&oldStatfs)

	return nil

}

func Fstatfs(fd int, st *Statfs_t) (err error) {

	var oldStatfs statfs_freebsd11_t

	if supportsABI(_ino64First) {

		return fstatfs_freebsd12(fd, st)

	}

	err = fstatfs(fd, &oldStatfs)

	if err != nil {

		return err

	}

	st.convertFrom(&oldStatfs)

	return nil

}

func Getdents(fd int, buf []byte) (n int, err error) {

	return Getdirentries(fd, buf, nil)

}

func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {

	if supportsABI(_ino64First) {

		if basep == nil || unsafe.Sizeof(*basep) == 8 {

			return getdirentries_freebsd12(fd, buf, (*uint64)(unsafe.Pointer(basep)))

		}

		// The freebsd12 syscall needs a 64-bit base. On 32-bit machines

		// we can't just use the basep passed in. See #32498.

		var base uint64 = uint64(*basep)

		n, err = getdirentries_freebsd12(fd, buf, &base)

		*basep = uintptr(base)

		if base>>32 != 0 {

			// We can't stuff the base back into a uintptr, so any

			// future calls would be suspect. Generate an error.

			// EIO is allowed by getdirentries.

			err = EIO

		}

		return

	}

	// The old syscall entries are smaller than the new. Use 1/4 of the original

	// buffer size rounded up to DIRBLKSIZ (see /usr/src/lib/libc/sys/getdirentries.c).

	oldBufLen := roundup(len(buf)/4, _dirblksiz)

	oldBuf := make([]byte, oldBufLen)

	n, err = getdirentries(fd, oldBuf, basep)

	if err == nil && n > 0 {

		n = convertFromDirents11(buf, oldBuf[:n])

	}

	return

}

func Mknod(path string, mode uint32, dev uint64) (err error) {

	var oldDev int

	if supportsABI(_ino64First) {

		return mknodat_freebsd12(AT_FDCWD, path, mode, dev)

	}

	oldDev = int(dev)

	return mknod(path, mode, oldDev)

}

func Mknodat(fd int, path string, mode uint32, dev uint64) (err error) {

	var oldDev int

	if supportsABI(_ino64First) {

		return mknodat_freebsd12(fd, path, mode, dev)

	}

	oldDev = int(dev)

	return mknodat(fd, path, mode, oldDev)

}

// round x to the nearest multiple of y, larger or equal to x.