package core:sys/kqueue

Source

Filter :: enum _Filter_Backing {
	Read   = _FILTER_READ,   // Check for read availability on the file descriptor.
	Write  = _FILTER_WRITE,  // Check for write availability on the file descriptor.
	AIO    = _FILTER_AIO,    // Attached to AIO requests.
	VNode  = _FILTER_VNODE,  // Check for changes to the subject file.
	Proc   = _FILTER_PROC,   // Check for changes to the subject process.
	Signal = _FILTER_SIGNAL, // Check for signals delivered to the process.
	Timer  = _FILTER_TIMER,  // Timers.
	User   = _FILTER_USER,   // User events.
}

Flag :: enum _Flags_Backing {
	Add      = log2(0x0001), // Add event to kq (implies .Enable).
	Delete   = log2(0x0002), // Delete event from kq.
	Enable   = log2(0x0004), // Enable event.
	Disable  = log2(0x0008), // Disable event (not reported).
	One_Shot = log2(0x0010), // Only report one occurrence.
	Clear    = log2(0x0020), // Clear event state after reporting.
	Receipt  = log2(0x0040), // Force immediate event output.
	Dispatch = log2(0x0080), // Disable event after reporting.
	Error    = log2(0x4000), // Error, data contains errno.
	EOF      = log2(0x8000), // EOF detected.
}

Flags :: bit_set[Flag; _Flags_Backing]

KEvent :: struct #align (4) {
	// Value used to identify this event. The exact interpretation is determined by the attached filter.
	ident:  uintptr,
	// Filter for event.
	filter: Filter,
	// General flags.
	flags:  bit_set[Flag; _Flags_Backing],
	// Filter specific flags.
	fflags: struct #raw_union {
		rw:    bit_set[RW_Flag; u32] `raw_union_tag:"filter=.Read, filter=.Write"`,
		vnode: bit_set[VNode_Flag; u32] `raw_union_tag:"filter=.VNode"`,
		fproc: bit_set[Proc_Flag; u32] `raw_union_tag:"filter=.Proc"`,
		// vm:    VM_Flags,
		timer: bit_set[Timer_Flag; u32] `raw_union_tag:"filter=.Timer"`,
		user:  bit_set[User_Flag; u32] `raw_union_tag:"filter=.User"`,
	},
	// Filter specific data.
	data:   i64,
	// Opaque user data passed through the kernel unchanged.
	udata:  rawptr,
}

KQ :: posix.FD

Proc_Flag :: enum u32 {
	Exit = log2(0x80000000), // Process exited.
	Fork = log2(0x40000000), // Process forked.
	Exec = log2(0x20000000), // Process exec'd.
}

Proc_Flags :: bit_set[Proc_Flag; u32]

RW_Flag :: enum u32 {
	Low_Water_Mark = log2(0x00000001), 
}

RW_Flags :: bit_set[RW_Flag; u32]

Timer_Flag :: enum u32 {
	Seconds  = log2(0x00000001),     // Data is seconds.
	USeconds = log2(_NOTE_USECONDS), // Data is microseconds.
	Absolute = log2(_NOTE_ABSOLUTE), // Absolute timeout.
}

Timer_Flags :: bit_set[Timer_Flag; u32]

User_Flag :: enum u32 {
	Trigger = log2(0x01000000), 
	FFAnd   = log2(0x40000000), 
	FFOr    = log2(0x80000000), 
}

User_Flags :: bit_set[User_Flag; u32]

VNode_Flag :: enum u32 {
	Delete = log2(0x00000001), // Deleted.
	Write  = log2(0x00000002), // Contents changed.
	Extend = log2(0x00000004), // Size increased.
	Attrib = log2(0x00000008), // Attributes changed.
	Link   = log2(0x00000010), // Link count changed.
	Rename = log2(0x00000020), // Renamed.
	Revoke = log2(0x00000040), // Access was revoked.
}

VNode_Flags :: bit_set[VNode_Flag; u32]

TIMER_FLAGS_NSECONDS: bit_set[Timer_Flag; u32] : _TIMER_FLAGS_NSECONDS

USER_FLAGS_CONTROL_MASK: bit_set[User_Flag; u32] : transmute(User_Flags)u32(0xc0000000)

USER_FLAGS_COPY: bit_set[User_Flag; u32] : User_Flags{.FFOr, .FFAnd}

USER_FLAGS_MASK: bit_set[User_Flag; u32] : transmute(User_Flags)u32(0x00FFFFFF)

kevent :: proc(kq: posix.FD, change_list: []KEvent, event_list: []KEvent, timeout: ^libc.timespec) -> (n_events: i32, err: posix.Errno) {…}

kqueue :: proc() -> (kq: posix.FD, err: posix.Errno) {…}