// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package disk

import (
	"os"
	"syscall"
)

// Fdatasync is fsync on freebsd/darwin
func Fdatasync(f *os.File) error {
	return syscall.Fsync(int(f.Fd()))
}

// FadviseDontNeed is a no-op
func FadviseDontNeed(f *os.File) error {
	return nil

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package disk

import (
	"os"
	"syscall"

	"golang.org/x/sys/unix"
)

// Fdatasync - fdatasync() is similar to fsync(), but does not flush modified metadata
// unless that metadata is needed in order to allow a subsequent data retrieval
// to  be  correctly  handled.   For example, changes to st_atime or st_mtime

			close(fd, callback) { callback(enosys()); },
			fchmod(fd, mode, callback) { callback(enosys()); },
			fchown(fd, uid, gid, callback) { callback(enosys()); },
			fstat(fd, callback) { callback(enosys()); },
			fsync(fd, callback) { callback(null); },
			ftruncate(fd, length, callback) { callback(enosys()); },
			lchown(path, uid, gid, callback) { callback(enosys()); },
			link(path, link, callback) { callback(enosys()); },

pkg strings, func IndexByte(string, uint8) int
pkg sync/atomic, func SwapInt32(*int32, int32) int32
pkg sync/atomic, func SwapInt64(*int64, int64) int64
pkg sync/atomic, func SwapPointer(*unsafe.Pointer, unsafe.Pointer) unsafe.Pointer
pkg sync/atomic, func SwapUint32(*uint32, uint32) uint32
pkg sync/atomic, func SwapUint64(*uint64, uint64) uint64
pkg sync/atomic, func SwapUintptr(*uintptr, uintptr) uintptr

pkg sync, method (*RWMutex) Unlock()
pkg sync, method (*WaitGroup) Add(int)
pkg sync, method (*WaitGroup) Done()
pkg sync, method (*WaitGroup) Wait()
pkg sync, type Cond struct
pkg sync, type Cond struct, L Locker
pkg sync, type Locker interface { Lock, Unlock }
pkg sync, type Locker interface, Lock()
pkg sync, type Locker interface, Unlock()
pkg sync, type Mutex struct
pkg sync, type Once struct

* Fix tests to use fsync instead of sync ([#69755](https://github.com/kubernetes/kubernetes/pull/69755), [@mrunalp](https://github.com/mrunalp))

pkg syscall (netbsd-arm64-cgo), func Fpathconf(int, int) (int, error)
pkg syscall (netbsd-arm64-cgo), func Fstat(int, *Stat_t) error
pkg syscall (netbsd-arm64-cgo), func Fsync(int) error
pkg syscall (netbsd-arm64-cgo), func Ftruncate(int, int64) error
pkg syscall (netbsd-arm64-cgo), func Futimes(int, []Timeval) error

pkg syscall (freebsd-arm64), func Fstatat(int, string, *Stat_t, int) error
pkg syscall (freebsd-arm64), func Fstatfs(int, *Statfs_t) error
pkg syscall (freebsd-arm64), func Fsync(int) error
pkg syscall (freebsd-arm64), func Ftruncate(int, int64) error
pkg syscall (freebsd-arm64), func Futimes(int, []Timeval) error
pkg syscall (freebsd-arm64), func Getdirentries(int, []uint8, *uintptr) (int, error)

So, about the egg and the chicken, how do you call the first `async` function?

If you are working with **FastAPI** you don't have to worry about that, because that "first" function will be your *path operation function*, and FastAPI will know how to do the right thing.

Gleichzeitig müssen aber mit `async def` definierte Funktionen „erwartet“ („awaited“) werden. Daher können Funktionen mit `async def` nur innerhalb von Funktionen aufgerufen werden, die auch mit `async def` definiert sind.

Daraus resultiert das Ei-und-Huhn-Problem: Wie ruft man die erste `async` Funktion auf?