1/*
2 * Copyright 2004-2009, Haiku Inc. All Rights Reserved.
3 * Distributed under the terms of the MIT License.
4 */
5#ifndef _OS_H
6#define _OS_H
7
8//! Kernel specific structures and functions
9
10#include <pthread.h>
11#include <stdarg.h>
12
13#include <SupportDefs.h>
14#include <StorageDefs.h>
15
16
17#ifdef __cplusplus
18extern "C" {
19#endif
20
21/* System constants */
22
23#define B_OS_NAME_LENGTH	32
24#define B_PAGE_SIZE			4096
25#define B_INFINITE_TIMEOUT	(9223372036854775807LL)
26
27enum {
28	B_TIMEOUT						= 0x8,	/* relative timeout */
29	B_RELATIVE_TIMEOUT				= 0x8,	/* fails after a relative timeout
30												with B_TIMED_OUT */
31	B_ABSOLUTE_TIMEOUT				= 0x10,	/* fails after an absolute timeout
32												with B_TIMED_OUT */
33
34	/* experimental Haiku only API */
35	B_TIMEOUT_REAL_TIME_BASE		= 0x40,
36	B_ABSOLUTE_REAL_TIME_TIMEOUT	= B_ABSOLUTE_TIMEOUT
37										| B_TIMEOUT_REAL_TIME_BASE
38};
39
40
41/* Types */
42
43typedef int32 area_id;
44typedef int32 port_id;
45typedef int32 sem_id;
46typedef int32 team_id;
47typedef int32 thread_id;
48
49
50/* Areas */
51
52typedef struct area_info {
53	area_id		area;
54	char		name[B_OS_NAME_LENGTH];
55	size_t		size;
56	uint32		lock;
57	uint32		protection;
58	team_id		team;
59	uint32		ram_size;
60	uint32		copy_count;
61	uint32		in_count;
62	uint32		out_count;
63	void		*address;
64} area_info;
65
66/* area locking */
67#define B_NO_LOCK				0
68#define B_LAZY_LOCK				1
69#define B_FULL_LOCK				2
70#define B_CONTIGUOUS			3
71#define	B_LOMEM					4	/* B_CONTIGUOUS, < 16 MB physical address */
72#define	B_32_BIT_FULL_LOCK		5	/* B_FULL_LOCK, < 4 GB physical addresses */
73#define	B_32_BIT_CONTIGUOUS		6	/* B_CONTIGUOUS, < 4 GB physical address */
74
75/* address spec for create_area(), and clone_area() */
76#define B_ANY_ADDRESS			0
77#define B_EXACT_ADDRESS			1
78#define B_BASE_ADDRESS			2
79#define B_CLONE_ADDRESS			3
80#define	B_ANY_KERNEL_ADDRESS	4
81
82/* area protection */
83#define B_READ_AREA				1
84#define B_WRITE_AREA			2
85
86extern area_id		create_area(const char *name, void **startAddress,
87						uint32 addressSpec, size_t size, uint32 lock,
88						uint32 protection);
89extern area_id		clone_area(const char *name, void **destAddress,
90						uint32 addressSpec, uint32 protection, area_id source);
91extern area_id		find_area(const char *name);
92extern area_id		area_for(void *address);
93extern status_t		delete_area(area_id id);
94extern status_t		resize_area(area_id id, size_t newSize);
95extern status_t		set_area_protection(area_id id, uint32 newProtection);
96
97/* system private, use macros instead */
98extern status_t		_get_area_info(area_id id, area_info *areaInfo, size_t size);
99extern status_t		_get_next_area_info(team_id team, ssize_t *cookie,
100						area_info *areaInfo, size_t size);
101
102#define get_area_info(id, areaInfo) \
103	_get_area_info((id), (areaInfo),sizeof(*(areaInfo)))
104#define get_next_area_info(team, cookie, areaInfo) \
105	_get_next_area_info((team), (cookie), (areaInfo), sizeof(*(areaInfo)))
106
107
108/* Ports */
109
110typedef struct port_info {
111	port_id		port;
112	team_id		team;
113	char		name[B_OS_NAME_LENGTH];
114	int32		capacity;		/* queue depth */
115	int32		queue_count;	/* # msgs waiting to be read */
116	int32		total_count;	/* total # msgs read so far */
117} port_info;
118
119extern port_id		create_port(int32 capacity, const char *name);
120extern port_id		find_port(const char *name);
121extern ssize_t		read_port(port_id port, int32 *code, void *buffer,
122						size_t bufferSize);
123extern ssize_t		read_port_etc(port_id port, int32 *code, void *buffer,
124						size_t bufferSize, uint32 flags, bigtime_t timeout);
125extern status_t		write_port(port_id port, int32 code, const void *buffer,
126						size_t bufferSize);
127extern status_t		write_port_etc(port_id port, int32 code, const void *buffer,
128						size_t bufferSize, uint32 flags, bigtime_t timeout);
129extern status_t		close_port(port_id port);
130extern status_t		delete_port(port_id port);
131
132extern ssize_t		port_buffer_size(port_id port);
133extern ssize_t		port_buffer_size_etc(port_id port, uint32 flags,
134						bigtime_t timeout);
135extern ssize_t		port_count(port_id port);
136extern status_t		set_port_owner(port_id port, team_id team);
137
138/* system private, use the macros instead */
139extern status_t		_get_port_info(port_id port, port_info *portInfo,
140						size_t portInfoSize);
141extern status_t		_get_next_port_info(team_id team, int32 *cookie,
142						port_info *portInfo, size_t portInfoSize);
143
144#define get_port_info(port, info) \
145	_get_port_info((port), (info), sizeof(*(info)))
146#define get_next_port_info(team, cookie, info) \
147	_get_next_port_info((team), (cookie), (info), sizeof(*(info)))
148
149
150/* WARNING: The following is Haiku experimental API. It might be removed or
151   changed in the future. */
152
153typedef struct port_message_info {
154	size_t		size;
155	uid_t		sender;
156	gid_t		sender_group;
157	team_id		sender_team;
158} port_message_info;
159
160/* similar to port_buffer_size_etc(), but returns (more) info */
161extern status_t		_get_port_message_info_etc(port_id port,
162						port_message_info *info, size_t infoSize, uint32 flags,
163						bigtime_t timeout);
164
165#define get_port_message_info_etc(port, info, flags, timeout) \
166	_get_port_message_info_etc((port), (info), sizeof(*(info)), flags, timeout)
167
168
169/* Semaphores */
170
171typedef struct sem_info {
172	sem_id		sem;
173	team_id		team;
174	char		name[B_OS_NAME_LENGTH];
175	int32		count;
176	thread_id	latest_holder;
177} sem_info;
178
179/* semaphore flags */
180enum {
181	B_CAN_INTERRUPT				= 0x01,	/* acquisition of the semaphore can be
182										   interrupted (system use only) */
183	B_CHECK_PERMISSION			= 0x04,	/* ownership will be checked (system use
184										   only) */
185	B_KILL_CAN_INTERRUPT		= 0x20,	/* acquisition of the semaphore can be
186										   interrupted by SIGKILL[THR], even
187										   if not B_CAN_INTERRUPT (system use
188										   only) */
189
190	/* release_sem_etc() only flags */
191	B_DO_NOT_RESCHEDULE			= 0x02,	/* thread is not rescheduled */
192	B_RELEASE_ALL				= 0x08,	/* all waiting threads will be woken up,
193										   count will be zeroed */
194	B_RELEASE_IF_WAITING_ONLY	= 0x10	/* release count only if there are any
195										   threads waiting */
196};
197
198extern sem_id		create_sem(int32 count, const char *name);
199extern status_t		delete_sem(sem_id id);
200extern status_t		acquire_sem(sem_id id);
201extern status_t		acquire_sem_etc(sem_id id, int32 count, uint32 flags,
202						bigtime_t timeout);
203extern status_t		release_sem(sem_id id);
204extern status_t		release_sem_etc(sem_id id, int32 count, uint32 flags);
205/* TODO: the following two calls are not part of the BeOS API, and might be
206   changed or even removed for the final release of Haiku R1 */
207extern status_t		switch_sem(sem_id semToBeReleased, sem_id id);
208extern status_t		switch_sem_etc(sem_id semToBeReleased, sem_id id,
209						int32 count, uint32 flags, bigtime_t timeout);
210extern status_t		get_sem_count(sem_id id, int32 *threadCount);
211extern status_t		set_sem_owner(sem_id id, team_id team);
212
213/* system private, use the macros instead */
214extern status_t		_get_sem_info(sem_id id, struct sem_info *info,
215						size_t infoSize);
216extern status_t		_get_next_sem_info(team_id team, int32 *cookie,
217						struct sem_info *info, size_t infoSize);
218
219#define get_sem_info(sem, info) \
220	_get_sem_info((sem), (info), sizeof(*(info)))
221
222#define get_next_sem_info(team, cookie, info) \
223	_get_next_sem_info((team), (cookie), (info), sizeof(*(info)))
224
225
226/* Teams */
227
228typedef struct {
229	team_id			team;
230	int32			thread_count;
231	int32			image_count;
232	int32			area_count;
233	thread_id		debugger_nub_thread;
234	port_id			debugger_nub_port;
235	int32			argc;
236	char			args[64];
237	uid_t			uid;
238	gid_t			gid;
239} team_info;
240
241#define B_CURRENT_TEAM	0
242#define B_SYSTEM_TEAM	1
243
244extern status_t		kill_team(team_id team);
245	/* see also: send_signal() */
246
247/* system private, use macros instead */
248extern status_t		_get_team_info(team_id id, team_info *info, size_t size);
249extern status_t		_get_next_team_info(int32 *cookie, team_info *info,
250						size_t size);
251
252#define get_team_info(id, info) \
253	_get_team_info((id), (info), sizeof(*(info)))
254
255#define get_next_team_info(cookie, info) \
256	_get_next_team_info((cookie), (info), sizeof(*(info)))
257
258/* team usage info */
259
260typedef struct {
261	bigtime_t		user_time;
262	bigtime_t		kernel_time;
263} team_usage_info;
264
265enum {
266	/* compatible to sys/resource.h RUSAGE_SELF and RUSAGE_CHILDREN */
267	B_TEAM_USAGE_SELF		= 0,
268	B_TEAM_USAGE_CHILDREN	= -1
269};
270
271/* system private, use macros instead */
272extern status_t		_get_team_usage_info(team_id team, int32 who,
273						team_usage_info *info, size_t size);
274
275#define get_team_usage_info(team, who, info) \
276	_get_team_usage_info((team), (who), (info), sizeof(*(info)))
277
278
279/* Threads */
280
281typedef enum {
282	B_THREAD_RUNNING	= 1,
283	B_THREAD_READY,
284	B_THREAD_RECEIVING,
285	B_THREAD_ASLEEP,
286	B_THREAD_SUSPENDED,
287	B_THREAD_WAITING
288} thread_state;
289
290typedef struct {
291	thread_id		thread;
292	team_id			team;
293	char			name[B_OS_NAME_LENGTH];
294	thread_state	state;
295	int32			priority;
296	sem_id			sem;
297	bigtime_t		user_time;
298	bigtime_t		kernel_time;
299	void			*stack_base;
300	void			*stack_end;
301} thread_info;
302
303#define B_IDLE_PRIORITY					0
304#define B_LOWEST_ACTIVE_PRIORITY		1
305#define B_LOW_PRIORITY					5
306#define B_NORMAL_PRIORITY				10
307#define B_DISPLAY_PRIORITY				15
308#define	B_URGENT_DISPLAY_PRIORITY		20
309#define	B_REAL_TIME_DISPLAY_PRIORITY	100
310#define	B_URGENT_PRIORITY				110
311#define B_REAL_TIME_PRIORITY			120
312
313#define B_SYSTEM_TIMEBASE				0
314	/* time base for snooze_*(), compatible with the clockid_t constants defined
315	   in <time.h> */
316
317#define B_FIRST_REAL_TIME_PRIORITY		B_REAL_TIME_DISPLAY_PRIORITY
318
319typedef status_t (*thread_func)(void *);
320#define thread_entry thread_func
321	/* thread_entry is for backward compatibility only! Use thread_func */
322
323extern thread_id	spawn_thread(thread_func, const char *name, int32 priority,
324						void *data);
325extern status_t		kill_thread(thread_id thread);
326extern status_t		resume_thread(thread_id thread);
327extern status_t		suspend_thread(thread_id thread);
328
329extern status_t		rename_thread(thread_id thread, const char *newName);
330extern status_t		set_thread_priority(thread_id thread, int32 newPriority);
331extern void			exit_thread(status_t status);
332extern status_t		wait_for_thread(thread_id thread, status_t *returnValue);
333extern status_t		on_exit_thread(void (*callback)(void *), void *data);
334
335extern thread_id 	find_thread(const char *name);
336
337extern status_t		send_data(thread_id thread, int32 code, const void *buffer,
338						size_t bufferSize);
339extern int32		receive_data(thread_id *sender, void *buffer,
340						size_t bufferSize);
341extern bool			has_data(thread_id thread);
342
343extern status_t		snooze(bigtime_t amount);
344extern status_t		snooze_etc(bigtime_t amount, int timeBase, uint32 flags);
345extern status_t		snooze_until(bigtime_t time, int timeBase);
346
347/* system private, use macros instead */
348extern status_t		_get_thread_info(thread_id id, thread_info *info, size_t size);
349extern status_t		_get_next_thread_info(team_id team, int32 *cookie,
350						thread_info *info, size_t size);
351
352#define get_thread_info(id, info) \
353	_get_thread_info((id), (info), sizeof(*(info)))
354
355#define get_next_thread_info(team, cookie, info) \
356	_get_next_thread_info((team), (cookie), (info), sizeof(*(info)))
357
358/* bridge to the pthread API */
359extern thread_id	get_pthread_thread_id(pthread_t thread);
360/* TODO: Would be nice to have, but we use TLS to associate a thread with its
361   pthread object. So this is not trivial to implement.
362extern status_t		convert_to_pthread(thread_id thread, pthread_t *_thread);
363*/
364
365
366/* Time */
367
368extern uint32		real_time_clock(void);
369extern void			set_real_time_clock(uint32 secsSinceJan1st1970);
370extern bigtime_t	real_time_clock_usecs(void);
371extern bigtime_t	system_time(void);
372						/* time since booting in microseconds */
373extern nanotime_t	system_time_nsecs();
374						/* time since booting in nanoseconds */
375
376					// deprecated (is no-op)
377extern status_t		set_timezone(const char *timezone);
378
379/* Alarm */
380
381enum {
382	B_ONE_SHOT_ABSOLUTE_ALARM	= 1,
383	B_ONE_SHOT_RELATIVE_ALARM,
384	B_PERIODIC_ALARM			/* "when" specifies the period */
385};
386
387extern bigtime_t	set_alarm(bigtime_t when, uint32 flags);
388
389
390/* Debugger */
391
392extern void			debugger(const char *message);
393
394/*
395   calling this function with a non-zero value will cause your thread
396   to receive signals for any exceptional conditions that occur (i.e.
397   you'll get SIGSEGV for data access exceptions, SIGFPE for floating
398   point errors, SIGILL for illegal instructions, etc).
399
400   to re-enable the default debugger pass a zero.
401*/
402extern int			disable_debugger(int state);
403
404/* TODO: Remove. Temporary debug helper. */
405extern void			debug_printf(const char *format, ...)
406						__attribute__ ((format (__printf__, 1, 2)));
407extern void			debug_vprintf(const char *format, va_list args);
408extern void			ktrace_printf(const char *format, ...)
409						__attribute__ ((format (__printf__, 1, 2)));
410extern void			ktrace_vprintf(const char *format, va_list args);
411
412
413/* System information */
414
415#if __INTEL__
416#	define B_MAX_CPU_COUNT	8
417#elif __x86_64__
418#	define B_MAX_CPU_COUNT	8
419#elif __POWERPC__
420#	define B_MAX_CPU_COUNT	8
421#elif __M68K__
422#	define B_MAX_CPU_COUNT	1
423#elif __ARM__
424#	define B_MAX_CPU_COUNT	1
425#elif __MIPSEL__
426#	define B_MAX_CPU_COUNT	1
427#else
428#	warning Unknown cpu
429#	define B_MAX_CPU_COUNT	1
430#endif
431
432typedef enum cpu_types {
433	/* TODO: add latest models */
434
435	/* Motorola/IBM */
436	B_CPU_PPC_UNKNOWN					= 0,
437	B_CPU_PPC_601						= 1,
438	B_CPU_PPC_602						= 7,
439	B_CPU_PPC_603						= 2,
440	B_CPU_PPC_603e						= 3,
441	B_CPU_PPC_603ev						= 8,
442	B_CPU_PPC_604						= 4,
443	B_CPU_PPC_604e						= 5,
444	B_CPU_PPC_604ev						= 9,
445	B_CPU_PPC_620						= 10,
446	B_CPU_PPC_750   					= 6,
447	B_CPU_PPC_686						= 13,
448	B_CPU_PPC_860						= 25,
449	B_CPU_PPC_7400						= 26,
450	B_CPU_PPC_7410						= 27,
451	B_CPU_PPC_7447A						= 28,
452	B_CPU_PPC_7448						= 29,
453	B_CPU_PPC_7450						= 30,
454	B_CPU_PPC_7455						= 31,
455	B_CPU_PPC_7457						= 32,
456	B_CPU_PPC_8240						= 33,
457	B_CPU_PPC_8245						= 34,
458
459	B_CPU_PPC_IBM_401A1					= 35,
460	B_CPU_PPC_IBM_401B2					= 36,
461	B_CPU_PPC_IBM_401C2					= 37,
462	B_CPU_PPC_IBM_401D2					= 38,
463	B_CPU_PPC_IBM_401E2					= 39,
464	B_CPU_PPC_IBM_401F2					= 40,
465	B_CPU_PPC_IBM_401G2					= 41,
466	B_CPU_PPC_IBM_403					= 42,
467	B_CPU_PPC_IBM_405GP					= 43,
468	B_CPU_PPC_IBM_405L					= 44,
469	B_CPU_PPC_IBM_750FX					= 45,
470	B_CPU_PPC_IBM_POWER3				= 46,
471
472	/* Intel */
473
474	/* Updated according to Intel(R) Processor Identification and
475	 * the  CPUID instruction (Table 4)
476	 * AP-485 Intel - 24161832.pdf
477	 */
478	B_CPU_INTEL_x86						= 0x1000,
479	B_CPU_INTEL_PENTIUM					= 0x1051,
480	B_CPU_INTEL_PENTIUM75,
481	B_CPU_INTEL_PENTIUM_486_OVERDRIVE,
482	B_CPU_INTEL_PENTIUM_MMX,
483	B_CPU_INTEL_PENTIUM_MMX_MODEL_4		= B_CPU_INTEL_PENTIUM_MMX,
484	B_CPU_INTEL_PENTIUM_MMX_MODEL_8		= 0x1058,
485	B_CPU_INTEL_PENTIUM75_486_OVERDRIVE,
486	B_CPU_INTEL_PENTIUM_PRO				= 0x1061,
487	B_CPU_INTEL_PENTIUM_II				= 0x1063,
488	B_CPU_INTEL_PENTIUM_II_MODEL_3		= 0x1063,
489	B_CPU_INTEL_PENTIUM_II_MODEL_5		= 0x1065,
490	B_CPU_INTEL_CELERON					= 0x1066,
491	B_CPU_INTEL_CELERON_MODEL_22		= 0x11066,
492	B_CPU_INTEL_PENTIUM_III				= 0x1067,
493	B_CPU_INTEL_PENTIUM_III_MODEL_8		= 0x1068,
494	B_CPU_INTEL_PENTIUM_M				= 0x1069,
495	B_CPU_INTEL_PENTIUM_III_XEON		= 0x106a,
496	B_CPU_INTEL_PENTIUM_III_MODEL_11 	= 0x106b,
497	B_CPU_INTEL_ATOM					= 0x1106c,
498	B_CPU_INTEL_PENTIUM_M_MODEL_13		= 0x106d, /* Dothan */
499	B_CPU_INTEL_PENTIUM_CORE,
500	B_CPU_INTEL_PENTIUM_CORE_2,
501	B_CPU_INTEL_PENTIUM_CORE_2_45_NM	= 0x11067, /* Core 2 on 45 nm
502	                                                   (Core 2 Extreme,
503	                                                   Xeon model 23 or
504	                                                   Core 2 Duo/Quad) */
505	B_CPU_INTEL_PENTIUM_CORE_I5_M430	= 0x21065, /* Core i5 M 430 @ 2.27 */
506	B_CPU_INTEL_PENTIUM_CORE_I7			= 0x1106a, /* Core i7 920 @ 2.6(6) */
507	B_CPU_INTEL_PENTIUM_CORE_I7_Q720	= 0x1106e, /* Core i7 Q720 @ 1.6 */
508	B_CPU_INTEL_PENTIUM_IV				= 0x10f0,
509	B_CPU_INTEL_PENTIUM_IV_MODEL_1,
510	B_CPU_INTEL_PENTIUM_IV_MODEL_2,
511	B_CPU_INTEL_PENTIUM_IV_MODEL_3,
512	B_CPU_INTEL_PENTIUM_IV_MODEL_4,
513
514	/* AMD */
515
516	// AMD Processor Recognition Application Note
517	B_CPU_AMD_x86						= 0x1100,
518
519	// Family 5h
520	B_CPU_AMD_K5_MODEL_0				= 0x1150,
521	B_CPU_AMD_K5_MODEL_1				= 0x1151,
522	B_CPU_AMD_K5_MODEL_2				= 0x1152,
523	B_CPU_AMD_K5_MODEL_3				= 0x1153,
524	B_CPU_AMD_K6_MODEL_6				= 0x1156,
525	B_CPU_AMD_K6_MODEL_7				= 0x1157,
526	B_CPU_AMD_K6_MODEL_8				= 0x1158,
527	B_CPU_AMD_K6_2						= 0x1158,
528	B_CPU_AMD_K6_MODEL_9				= 0x1159,
529	B_CPU_AMD_K6_III					= 0x1159,
530	B_CPU_AMD_K6_III_MODEL_13			= 0x115d,
531
532	B_CPU_AMD_GEODE_LX					= 0x115a,
533
534	// Family 6h
535	B_CPU_AMD_ATHLON_MODEL_1			= 0x1161,
536	B_CPU_AMD_ATHLON_MODEL_2			= 0x1162,
537
538	B_CPU_AMD_DURON 					= 0x1163,
539
540	B_CPU_AMD_ATHLON_THUNDERBIRD		= 0x1164,
541	B_CPU_AMD_ATHLON_XP_MODEL_6			= 0x1166,
542	B_CPU_AMD_ATHLON_XP_MODEL_7			= 0x1167,
543	B_CPU_AMD_ATHLON_XP_MODEL_8			= 0x1168,
544	B_CPU_AMD_ATHLON_XP_MODEL_10		= 0x116a, /* Barton */
545
546	// Family fh
547	B_CPU_AMD_ATHLON_64_MODEL_3			= 0x11f3,
548	B_CPU_AMD_ATHLON_64_MODEL_4			= 0x11f4,
549	B_CPU_AMD_ATHLON_64_MODEL_7			= 0x11f7,
550	B_CPU_AMD_ATHLON_64_MODEL_8			= 0x11f8,
551	B_CPU_AMD_ATHLON_64_MODEL_11		= 0x11fb,
552	B_CPU_AMD_ATHLON_64_MODEL_12		= 0x11fc,
553	B_CPU_AMD_ATHLON_64_MODEL_14		= 0x11fe,
554	B_CPU_AMD_ATHLON_64_MODEL_15		= 0x11ff,
555	B_CPU_AMD_ATHLON_64_MODEL_20		= 0x111f4,
556	B_CPU_AMD_ATHLON_64_MODEL_23		= 0x111f7,
557	B_CPU_AMD_ATHLON_64_MODEL_24		= 0x111f8,
558	B_CPU_AMD_ATHLON_64_MODEL_27		= 0x111fb,
559	B_CPU_AMD_ATHLON_64_MODEL_28		= 0x111fc,
560	B_CPU_AMD_ATHLON_64_MODEL_31		= 0x111ff,
561	B_CPU_AMD_ATHLON_64_MODEL_35		= 0x211f3,
562	B_CPU_AMD_ATHLON_64_MODEL_43		= 0x211fb,
563	B_CPU_AMD_ATHLON_64_MODEL_44		= 0x211fc,
564	B_CPU_AMD_ATHLON_64_MODEL_47		= 0x211ff,
565	B_CPU_AMD_ATHLON_64_MODEL_63		= 0x311ff,
566	B_CPU_AMD_ATHLON_64_MODEL_79		= 0x411ff,
567	B_CPU_AMD_ATHLON_64_MODEL_95		= 0x511ff,
568	B_CPU_AMD_ATHLON_64_MODEL_127		= 0x711ff,
569
570	B_CPU_AMD_OPTERON_MODEL_5			= 0x11f5,
571	B_CPU_AMD_OPTERON_MODEL_21			= 0x111f5,
572	B_CPU_AMD_OPTERON_MODEL_33			= 0x211f1,
573	B_CPU_AMD_OPTERON_MODEL_37			= 0x211f5,
574	B_CPU_AMD_OPTERON_MODEL_39			= 0x211f7,
575
576	B_CPU_AMD_TURION_64_MODEL_36		= 0x211f4,
577	B_CPU_AMD_TURION_64_MODEL_76		= 0x411fc,
578	B_CPU_AMD_TURION_64_MODEL_104		= 0x611f8,
579
580	// Family 10h
581	B_CPU_AMD_PHENOM_MODEL_2			= 0x1011f2,
582	B_CPU_AMD_PHENOM_II_MODEL_4			= 0x1011f4,
583	B_CPU_AMD_PHENOM_II_MODEL_5			= 0x1011f5,
584	B_CPU_AMD_PHENOM_II_MODEL_6			= 0x1011f6,
585	B_CPU_AMD_PHENOM_II_MODEL_10		= 0x1011fa,
586
587	// Family 12h
588	B_CPU_AMD_A_SERIES					= 0x3011f1,
589
590	// Family 14h
591	B_CPU_AMD_C_SERIES					= 0x5011f1,
592	B_CPU_AMD_E_SERIES					= 0x5011f2,
593
594	// Family 15h
595	B_CPU_AMD_FX_SERIES					= 0x6011f1, /* Bulldozer */
596
597	/* VIA/Cyrix */
598	B_CPU_CYRIX_x86						= 0x1200,
599	B_CPU_VIA_CYRIX_x86					= 0x1200,
600	B_CPU_CYRIX_GXm						= 0x1254,
601	B_CPU_CYRIX_6x86MX					= 0x1260,
602
603	/* VIA/IDT */
604	B_CPU_IDT_x86						= 0x1300,
605	B_CPU_VIA_IDT_x86					= 0x1300,
606	B_CPU_IDT_WINCHIP_C6				= 0x1354,
607	B_CPU_IDT_WINCHIP_2					= 0x1358,
608	B_CPU_IDT_WINCHIP_3,
609	B_CPU_VIA_C3_SAMUEL					= 0x1366,
610	B_CPU_VIA_C3_SAMUEL_2				= 0x1367,
611	B_CPU_VIA_C3_EZRA_T					= 0x1368,
612	B_CPU_VIA_C3_NEHEMIAH				= 0x1369,
613	B_CPU_VIA_C7_ESTHER					= 0x136a,
614	B_CPU_VIA_C7_ESTHER_2				= 0x136d,
615	B_CPU_VIA_NANO_ISAIAH				= 0x136f,
616
617	/* Transmeta */
618	B_CPU_TRANSMETA_x86					= 0x1600,
619	B_CPU_TRANSMETA_CRUSOE				= 0x1654,
620	B_CPU_TRANSMETA_EFFICEON			= 0x16f2,
621	B_CPU_TRANSMETA_EFFICEON_2			= 0x16f3,
622
623	/* Rise */
624	B_CPU_RISE_x86						= 0x1400,
625	B_CPU_RISE_mP6						= 0x1450,
626
627	/* National Semiconductor */
628	B_CPU_NATIONAL_x86					= 0x1500,
629	B_CPU_NATIONAL_GEODE_GX1			= 0x1554,
630	B_CPU_NATIONAL_GEODE_GX2,
631
632	/* For compatibility */
633	B_CPU_AMD_29K						= 14,
634	B_CPU_x86,
635	B_CPU_MC6502,
636	B_CPU_Z80,
637	B_CPU_ALPHA,
638	B_CPU_MIPS,
639	B_CPU_HPPA,
640	B_CPU_M68K,
641	B_CPU_ARM,
642	B_CPU_SH,
643	B_CPU_SPARC
644} cpu_type;
645
646#define B_CPU_x86_VENDOR_MASK	0xff00
647
648#if defined(__INTEL__) || defined(__x86_64__)
649typedef union {
650	struct {
651		uint32	max_eax;
652		char	vendor_id[12];
653	} eax_0;
654
655	struct {
656		uint32	stepping		: 4;
657		uint32	model			: 4;
658		uint32	family			: 4;
659		uint32	type			: 2;
660		uint32	reserved_0		: 2;
661		uint32	extended_model	: 4;
662		uint32	extended_family	: 8;
663		uint32	reserved_1		: 4;
664
665		uint32	brand_index		: 8;
666		uint32	clflush			: 8;
667		uint32	logical_cpus	: 8;
668		uint32	apic_id			: 8;
669
670		uint32	features;
671		uint32	extended_features;
672	} eax_1;
673
674	struct {
675		uint8	call_num;
676		uint8	cache_descriptors[15];
677	} eax_2;
678
679	struct {
680		uint32	reserved[2];
681		uint32	serial_number_high;
682		uint32	serial_number_low;
683	} eax_3;
684
685	char		as_chars[16];
686
687	struct {
688		uint32	eax;
689		uint32	ebx;
690		uint32	edx;
691		uint32	ecx;
692	} regs;
693} cpuid_info;
694
695extern status_t		get_cpuid(cpuid_info *info, uint32 eaxRegister,
696						uint32 cpuNum);
697#endif
698
699
700typedef enum platform_types {
701	B_BEBOX_PLATFORM = 0,
702	B_MAC_PLATFORM,
703	B_AT_CLONE_PLATFORM,
704	B_ENIAC_PLATFORM,
705	B_APPLE_II_PLATFORM,
706	B_CRAY_PLATFORM,
707	B_LISA_PLATFORM,
708	B_TI_994A_PLATFORM,
709	B_TIMEX_SINCLAIR_PLATFORM,
710	B_ORAC_1_PLATFORM,
711	B_HAL_PLATFORM,
712	B_BESM_6_PLATFORM,
713	B_MK_61_PLATFORM,
714	B_NINTENDO_64_PLATFORM,
715	B_AMIGA_PLATFORM,
716	B_ATARI_PLATFORM,
717	B_64_BIT_PC_PLATFORM
718} platform_type;
719
720typedef struct {
721	bigtime_t	active_time;	/* usec of doing useful work since boot */
722} cpu_info;
723
724
725typedef int32 machine_id[2];	/* unique machine ID */
726
727typedef struct {
728	machine_id		id;					/* unique machine ID */
729	bigtime_t		boot_time;			/* time of boot (usecs since 1/1/1970) */
730
731	int32			cpu_count;			/* number of cpus */
732	enum cpu_types	cpu_type;			/* type of cpu */
733	int32			cpu_revision;		/* revision # of cpu */
734	cpu_info		cpu_infos[B_MAX_CPU_COUNT];	/* info about individual cpus */
735	int64			cpu_clock_speed;	/* processor clock speed (Hz) */
736	int64			bus_clock_speed;	/* bus clock speed (Hz) */
737	enum platform_types platform_type;	/* type of machine we're on */
738
739	int32			max_pages;			/* total # of accessible pages */
740	int32			used_pages;			/* # of accessible pages in use */
741	int32			page_faults;		/* # of page faults */
742	int32			max_sems;
743	int32			used_sems;
744	int32			max_ports;
745	int32			used_ports;
746	int32			max_threads;
747	int32			used_threads;
748	int32			max_teams;
749	int32			used_teams;
750
751	char			kernel_name[B_FILE_NAME_LENGTH];
752	char			kernel_build_date[B_OS_NAME_LENGTH];
753	char			kernel_build_time[B_OS_NAME_LENGTH];
754	int64			kernel_version;
755
756	bigtime_t		_busy_wait_time;	/* reserved for whatever */
757
758	int32			cached_pages;
759	uint32			abi;				/* the system API */
760	int32			ignored_pages;		/* # of ignored/inaccessible pages */
761	int32			pad;
762} system_info;
763
764/* system private, use macro instead */
765extern status_t		_get_system_info(system_info *info, size_t size);
766
767#define get_system_info(info) \
768	_get_system_info((info), sizeof(*(info)))
769
770extern int32		is_computer_on(void);
771extern double		is_computer_on_fire(void);
772
773
774/* signal related functions */
775int		send_signal(thread_id threadID, unsigned int signal);
776void	set_signal_stack(void* base, size_t size);
777
778
779/* WARNING: Experimental API! */
780
781enum {
782	B_OBJECT_TYPE_FD		= 0,
783	B_OBJECT_TYPE_SEMAPHORE	= 1,
784	B_OBJECT_TYPE_PORT		= 2,
785	B_OBJECT_TYPE_THREAD	= 3
786};
787
788enum {
789	B_EVENT_READ				= 0x0001,	/* FD/port readable */
790	B_EVENT_WRITE				= 0x0002,	/* FD/port writable */
791	B_EVENT_ERROR				= 0x0004,	/* FD error */
792	B_EVENT_PRIORITY_READ		= 0x0008,	/* FD priority readable */
793	B_EVENT_PRIORITY_WRITE		= 0x0010,	/* FD priority writable */
794	B_EVENT_HIGH_PRIORITY_READ	= 0x0020,	/* FD high priority readable */
795	B_EVENT_HIGH_PRIORITY_WRITE	= 0x0040,	/* FD high priority writable */
796	B_EVENT_DISCONNECTED		= 0x0080,	/* FD disconnected */
797
798	B_EVENT_ACQUIRE_SEMAPHORE	= 0x0001,	/* semaphore can be acquired */
799
800	B_EVENT_INVALID				= 0x1000	/* FD/port/sem/thread ID not or
801											   no longer valid (e.g. has been
802											   close/deleted) */
803};
804
805typedef struct object_wait_info {
806	int32		object;						/* ID of the object */
807	uint16		type;						/* type of the object */
808	uint16		events;						/* events mask */
809} object_wait_info;
810
811/* wait_for_objects[_etc]() waits until at least one of the specified events or,
812   if given, the timeout occurred. When entering the function the
813   object_wait_info::events field specifies the events for each object the
814   caller is interested in. When the function returns the fields reflect the
815   events that actually occurred. The events B_EVENT_INVALID, B_EVENT_ERROR,
816   and B_EVENT_DISCONNECTED don't need to be specified. They will always be
817   reported, when they occur. */
818
819extern ssize_t		wait_for_objects(object_wait_info* infos, int numInfos);
820extern ssize_t		wait_for_objects_etc(object_wait_info* infos, int numInfos,
821						uint32 flags, bigtime_t timeout);
822
823
824#ifdef __cplusplus
825}
826#endif
827
828#endif /* _OS_H */
829