haiku.git

/*
 * Copyright 2005-2008, Haiku Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _KERNEL_EXPORT_H
#define _KERNEL_EXPORT_H


#include <SupportDefs.h>
#include <OS.h>


/* interrupts and spinlocks */

typedef ulong cpu_status;

// WARNING: For Haiku debugging only! This changes the spinlock type in a
// binary incompatible way!
//#define B_DEBUG_SPINLOCK_CONTENTION	1

#if B_DEBUG_SPINLOCK_CONTENTION
	typedef struct {
		int32	lock;
		int32		failed_try_acquire;
		bigtime_t	total_wait;
		bigtime_t	total_held;
		bigtime_t	last_acquired;
	} spinlock;

#	define B_SPINLOCK_INITIALIZER { 0, 0, 0, 0, 0 }
#	define B_INITIALIZE_SPINLOCK(spinlock)	do {	\
			(spinlock)->lock = 0;					\
			(spinlock)->failed_try_acquire = 0;		\
			(spinlock)->total_wait = 0;				\
			(spinlock)->total_held = 0;				\
			(spinlock)->last_acquired = 0;			\
		} while (false)
#else
	typedef struct {
		int32	lock;
	} spinlock;

#	define B_SPINLOCK_INITIALIZER { 0 }
#	define B_INITIALIZE_SPINLOCK(spinlock)	do {	\
			(spinlock)->lock = 0;					\
		} while (false)
#endif

#define B_SPINLOCK_IS_LOCKED(spinlock)	(atomic_get(&(spinlock)->lock) > 0)

typedef struct {
	int32		lock;
} rw_spinlock;

#define B_RW_SPINLOCK_INITIALIZER	{ 0 }
#define B_INITIALIZE_RW_SPINLOCK(rw_spinlock)	do {	\
		(rw_spinlock)->lock = 0;						\
	} while (false)

typedef struct {
	spinlock	lock;
	uint32		count;
} seqlock;

#define B_SEQLOCK_INITIALIZER	{ B_SPINLOCK_INITIALIZER, 0 }
#define B_INITIALIZE_SEQLOCK(seqlock)	do {		\
		B_INITIALIZE_SPINLOCK(&(seqlock)->lock);	\
		(seqlock)->count = 0;						\
	} while (false)

/* interrupt handling support for device drivers */

typedef int32 (*interrupt_handler)(void *data);

/* Values returned by interrupt handlers */
#define B_UNHANDLED_INTERRUPT	0	/* pass to next handler */
#define B_HANDLED_INTERRUPT		1	/* don't pass on */
#define B_INVOKE_SCHEDULER		2	/* don't pass on; invoke the scheduler */

/* Flags that can be passed to install_io_interrupt_handler() */
#define B_NO_ENABLE_COUNTER		1


/* timer interrupts services */

typedef struct timer timer;
typedef	int32 (*timer_hook)(timer *);

struct timer {
	struct timer *next;
	int64		schedule_time;
	void		*user_data;
	uint16		flags;
	uint16		cpu;
	timer_hook	hook;
	bigtime_t	period;
};

#define B_ONE_SHOT_ABSOLUTE_TIMER	1
#define	B_ONE_SHOT_RELATIVE_TIMER	2
#define	B_PERIODIC_TIMER			3


/* virtual memory buffer functions */

#define B_DMA_IO		0x00000001
#define B_READ_DEVICE	0x00000002

typedef struct {
	phys_addr_t	address;	/* address in physical memory */
	phys_size_t	size;		/* size of block */
} physical_entry;

/* address specifications for mapping physical memory */
#define	B_ANY_KERNEL_BLOCK_ADDRESS	(B_ANY_KERNEL_ADDRESS + 1)

/* memory types for physical memory */
#define B_UNCACHED_MEMORY			(1 << 28)
#define B_WRITE_COMBINING_MEMORY	(2 << 28)
#define B_WRITE_THROUGH_MEMORY		(3 << 28)
#define B_WRITE_PROTECTED_MEMORY	(4 << 28)
#define B_WRITE_BACK_MEMORY			(5 << 28)
#define B_MEMORY_TYPE_MASK			(0xf0000000)

/* area protection flags for the kernel */
#define B_KERNEL_READ_AREA			(1 << 4)
#define B_KERNEL_WRITE_AREA			(1 << 5)
#define B_KERNEL_EXECUTE_AREA		(1 << 6)
#define B_KERNEL_STACK_AREA			(1 << 7)


/* kernel daemon service */

typedef void (*daemon_hook)(void *arg, int iteration);


/* kernel debugging facilities */

/* special return codes for kernel debugger */
#define B_KDEBUG_CONT	2
#define B_KDEBUG_QUIT	3

typedef int (*debugger_command_hook)(int argc, char **argv);


#ifdef __cplusplus
extern "C" {
#endif

/* interrupts, spinlock, and timers */
extern cpu_status	disable_interrupts(void);
extern void			restore_interrupts(cpu_status status);

extern void			acquire_spinlock(spinlock *lock);
extern void			release_spinlock(spinlock *lock);

extern bool			try_acquire_write_spinlock(rw_spinlock* lock);
extern void			acquire_write_spinlock(rw_spinlock* lock);
extern void			release_write_spinlock(rw_spinlock* lock);
extern bool			try_acquire_read_spinlock(rw_spinlock* lock);
extern void			acquire_read_spinlock(rw_spinlock* lock);
extern void			release_read_spinlock(rw_spinlock* lock);

extern bool			try_acquire_write_seqlock(seqlock* lock);
extern void			acquire_write_seqlock(seqlock* lock);
extern void			release_write_seqlock(seqlock* lock);
extern uint32		acquire_read_seqlock(seqlock* lock);
extern bool			release_read_seqlock(seqlock* lock, uint32 count);

extern status_t		install_io_interrupt_handler(int32 interrupt_number,
						interrupt_handler handler, void *data, uint32 flags);
extern status_t		remove_io_interrupt_handler(int32 interrupt_number,
						interrupt_handler handler, void	*data);

extern status_t		add_timer(timer *t, timer_hook hook, bigtime_t period,
						int32 flags);
extern bool			cancel_timer(timer *t);

/* kernel threads */
extern thread_id	spawn_kernel_thread(thread_func function,
						const char *name, int32 priority, void *arg);

/* signal functions */
extern int			send_signal_etc(pid_t thread, uint signal, uint32 flags);

/* virtual memory */
extern status_t		lock_memory_etc(team_id team, void *buffer, size_t numBytes,
						uint32 flags);
extern status_t		lock_memory(void *buffer, size_t numBytes, uint32 flags);
extern status_t		unlock_memory_etc(team_id team, void *address,
						size_t numBytes, uint32 flags);
extern status_t		unlock_memory(void *buffer, size_t numBytes, uint32 flags);
extern status_t		get_memory_map_etc(team_id team, const void *address,
						size_t numBytes, physical_entry *table,
						uint32* _numEntries);
extern int32		get_memory_map(const void *buffer, size_t size,
						physical_entry *table, int32 numEntries);
extern area_id		map_physical_memory(const char *areaName,
						phys_addr_t physicalAddress, size_t size, uint32 flags,
						uint32 protection, void **_mappedAddress);

/* kernel debugging facilities */
#if defined(_KERNEL_MODE) || defined(_BOOT_MODE)
extern void			dprintf(const char *format, ...) _PRINTFLIKE(1, 2);
#endif
extern void			dvprintf(const char *format, va_list args);
extern void			kprintf(const char *fmt, ...) _PRINTFLIKE(1, 2);

extern void			dump_block(const char *buffer, int size, const char *prefix);
						/* TODO: temporary API: hexdumps given buffer */

extern bool			set_dprintf_enabled(bool new_state);

extern void			panic(const char *format, ...) _PRINTFLIKE(1, 2);

extern void			kernel_debugger(const char *message);
extern uint64		parse_expression(const char *string);

extern int			add_debugger_command(const char *name,
						debugger_command_hook hook, const char *help);
extern int			remove_debugger_command(const char *name,
						debugger_command_hook hook);

/* Miscellaneous */
extern void			spin(bigtime_t microseconds);

extern status_t		register_kernel_daemon(daemon_hook hook, void *arg,
						int frequency);
extern status_t		unregister_kernel_daemon(daemon_hook hook, void *arg);

extern void			call_all_cpus(void (*func)(void *, int), void *cookie);
extern void			call_all_cpus_sync(void (*func)(void *, int), void *cookie);
extern void			memory_read_barrier(void);
extern void			memory_write_barrier(void);

/* safe methods to access user memory without having to lock it */
extern status_t		user_memcpy(void *to, const void *from, size_t size);
extern ssize_t		user_strlcpy(char *to, const char *from, size_t size);
extern status_t		user_memset(void *start, char c, size_t count);

#ifdef __cplusplus
}
#endif

#endif	/* _KERNEL_EXPORT_H */