1/*
2 * Copyright 2005-2008, Haiku Inc. All Rights Reserved.
3 * Distributed under the terms of the MIT License.
4 */
5#ifndef _KERNEL_EXPORT_H
6#define _KERNEL_EXPORT_H
7
8
9#include <SupportDefs.h>
10#include <OS.h>
11
12
13/* interrupts and spinlocks */
14
15typedef ulong cpu_status;
16
17// WARNING: For Haiku debugging only! This changes the spinlock type in a
18// binary incompatible way!
19//#define B_DEBUG_SPINLOCK_CONTENTION	1
20
21#if B_DEBUG_SPINLOCK_CONTENTION
22	typedef struct {
23		int32	lock;
24		int32	count_low;
25		int32	count_high;
26	} spinlock;
27
28#	define B_SPINLOCK_INITIALIZER { 0, 0, 0 }
29#	define B_INITIALIZE_SPINLOCK(spinlock)	do {	\
30			(spinlock)->lock = 0;					\
31			(spinlock)->count_low = 0;				\
32			(spinlock)->count_high = 0;				\
33		} while (false)
34#else
35	typedef struct {
36		int32	lock;
37	} spinlock;
38
39#	define B_SPINLOCK_INITIALIZER { 0 }
40#	define B_INITIALIZE_SPINLOCK(spinlock)	do {	\
41			(spinlock)->lock = 0;					\
42		} while (false)
43#endif
44
45#define B_SPINLOCK_IS_LOCKED(spinlock)	(atomic_get(&(spinlock)->lock) > 0)
46
47typedef struct {
48	int32		lock;
49} rw_spinlock;
50
51#define B_RW_SPINLOCK_INITIALIZER	{ 0 }
52#define B_INITIALIZE_RW_SPINLOCK(rw_spinlock)	do {	\
53		(rw_spinlock)->lock = 0;						\
54	} while (false)
55
56typedef struct {
57	spinlock	lock;
58	uint32		count;
59} seqlock;
60
61#define B_SEQLOCK_INITIALIZER	{ B_SPINLOCK_INITIALIZER, 0 }
62#define B_INITIALIZE_SEQLOCK(seqlock)	do {		\
63		B_INITIALIZE_SPINLOCK(&(seqlock)->lock);	\
64		(seqlock)->count = 0;						\
65	} while (false)
66
67/* interrupt handling support for device drivers */
68
69typedef int32 (*interrupt_handler)(void *data);
70
71/* Values returned by interrupt handlers */
72#define B_UNHANDLED_INTERRUPT	0	/* pass to next handler */
73#define B_HANDLED_INTERRUPT		1	/* don't pass on */
74#define B_INVOKE_SCHEDULER		2	/* don't pass on; invoke the scheduler */
75
76/* Flags that can be passed to install_io_interrupt_handler() */
77#define B_NO_ENABLE_COUNTER		1
78
79
80/* timer interrupts services */
81
82typedef struct timer timer;
83typedef	int32 (*timer_hook)(timer *);
84
85struct timer {
86	struct timer *next;
87	int64		schedule_time;
88	void		*user_data;
89	uint16		flags;
90	uint16		cpu;
91	timer_hook	hook;
92	bigtime_t	period;
93};
94
95#define B_ONE_SHOT_ABSOLUTE_TIMER	1
96#define	B_ONE_SHOT_RELATIVE_TIMER	2
97#define	B_PERIODIC_TIMER			3
98
99
100/* virtual memory buffer functions */
101
102#define B_DMA_IO		0x00000001
103#define B_READ_DEVICE	0x00000002
104
105typedef struct {
106	phys_addr_t	address;	/* address in physical memory */
107	phys_size_t	size;		/* size of block */
108} physical_entry;
109
110/* address specifications for mapping physical memory */
111#define	B_ANY_KERNEL_BLOCK_ADDRESS	(B_ANY_KERNEL_ADDRESS + 1)
112
113/* area protection flags for the kernel */
114#define B_KERNEL_READ_AREA			(1 << 4)
115#define B_KERNEL_WRITE_AREA			(1 << 5)
116
117/* MTR attributes for mapping physical memory (Intel Architecture only) */
118// TODO: rename those to something more meaningful
119#define	B_MTR_UC	0x10000000
120#define	B_MTR_WC	0x20000000
121#define	B_MTR_WT	0x30000000
122#define	B_MTR_WP	0x40000000
123#define	B_MTR_WB	0x50000000
124#define	B_MTR_MASK	0xf0000000
125
126
127/* kernel daemon service */
128
129typedef void (*daemon_hook)(void *arg, int iteration);
130
131
132/* kernel debugging facilities */
133
134/* special return codes for kernel debugger */
135#define  B_KDEBUG_CONT   2
136#define  B_KDEBUG_QUIT   3
137
138typedef int (*debugger_command_hook)(int argc, char **argv);
139
140
141#ifdef __cplusplus
142extern "C" {
143#endif
144
145/* interrupts, spinlock, and timers */
146extern cpu_status	disable_interrupts(void);
147extern void			restore_interrupts(cpu_status status);
148
149extern void			acquire_spinlock(spinlock *lock);
150extern void			release_spinlock(spinlock *lock);
151
152extern bool			try_acquire_write_spinlock(rw_spinlock* lock);
153extern void			acquire_write_spinlock(rw_spinlock* lock);
154extern void			release_write_spinlock(rw_spinlock* lock);
155extern bool			try_acquire_read_spinlock(rw_spinlock* lock);
156extern void			acquire_read_spinlock(rw_spinlock* lock);
157extern void			release_read_spinlock(rw_spinlock* lock);
158
159extern bool			try_acquire_write_seqlock(seqlock* lock);
160extern void			acquire_write_seqlock(seqlock* lock);
161extern void			release_write_seqlock(seqlock* lock);
162extern uint32		acquire_read_seqlock(seqlock* lock);
163extern bool			release_read_seqlock(seqlock* lock, uint32 count);
164
165extern status_t		install_io_interrupt_handler(long interrupt_number,
166						interrupt_handler handler, void *data, ulong flags);
167extern status_t		remove_io_interrupt_handler(long interrupt_number,
168						interrupt_handler handler, void	*data);
169
170extern status_t		add_timer(timer *t, timer_hook hook, bigtime_t period,
171						int32 flags);
172extern bool			cancel_timer(timer *t);
173
174/* kernel threads */
175extern thread_id	spawn_kernel_thread(thread_func function,
176						const char *name, int32 priority, void *arg);
177
178/* signal functions */
179extern int			send_signal_etc(pid_t thread, uint signal, uint32 flags);
180
181/* virtual memory */
182extern status_t		lock_memory_etc(team_id team, void *buffer, size_t numBytes,
183						uint32 flags);
184extern status_t		lock_memory(void *buffer, size_t numBytes, uint32 flags);
185extern status_t		unlock_memory_etc(team_id team, void *address,
186						size_t numBytes, uint32 flags);
187extern status_t		unlock_memory(void *buffer, size_t numBytes, uint32 flags);
188extern status_t		get_memory_map_etc(team_id team, const void *address,
189						size_t numBytes, physical_entry *table,
190						uint32* _numEntries);
191extern int32		get_memory_map(const void *buffer, size_t size,
192						physical_entry *table, int32 numEntries);
193extern area_id		map_physical_memory(const char *areaName,
194						phys_addr_t physicalAddress, size_t size, uint32 flags,
195						uint32 protection, void **_mappedAddress);
196
197/* kernel debugging facilities */
198extern void			dprintf(const char *format, ...) _PRINTFLIKE(1, 2);
199extern void			dvprintf(const char *format, va_list args);
200extern void			kprintf(const char *fmt, ...) _PRINTFLIKE(1, 2);
201
202extern void 		dump_block(const char *buffer, int size, const char *prefix);
203						/* TODO: temporary API: hexdumps given buffer */
204
205extern bool			set_dprintf_enabled(bool new_state);
206
207extern void			panic(const char *format, ...) _PRINTFLIKE(1, 2);
208
209extern void			kernel_debugger(const char *message);
210extern uint64		parse_expression(const char *string);
211
212extern int			add_debugger_command(const char *name,
213						debugger_command_hook hook, const char *help);
214extern int			remove_debugger_command(const char *name,
215						debugger_command_hook hook);
216
217/* Miscellaneous */
218extern void			spin(bigtime_t microseconds);
219
220extern status_t		register_kernel_daemon(daemon_hook hook, void *arg,
221						int frequency);
222extern status_t		unregister_kernel_daemon(daemon_hook hook, void *arg);
223
224extern void			call_all_cpus(void (*func)(void *, int), void *cookie);
225extern void			call_all_cpus_sync(void (*func)(void *, int), void *cookie);
226extern void			memory_read_barrier(void);
227extern void			memory_write_barrier(void);
228
229/* safe methods to access user memory without having to lock it */
230extern status_t		user_memcpy(void *to, const void *from, size_t size);
231extern ssize_t		user_strlcpy(char *to, const char *from, size_t size);
232extern status_t		user_memset(void *start, char c, size_t count);
233
234#ifdef __cplusplus
235}
236#endif
237
238#endif	/* _KERNEL_EXPORT_H */
239