Completed, rearranged, and cleaned up OS.h. Moved some typedefs from ktypes.h
to this place. Also removed create_sem_etc() from there, that shouldn't be a public call. Cleaned up image.h. git-svn-id: file:///srv/svn/repos/haiku/trunk/current@1377 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
+426
-283
@@ -1,35 +1,10 @@
|
||||
/* OS.h
|
||||
*/
|
||||
/* OS.h - kernel specific structures and functions
|
||||
**
|
||||
** Distributed under the terms of the OpenBeOS License.
|
||||
*/
|
||||
|
||||
#ifndef _OS_H
|
||||
#define _OS_H
|
||||
|
||||
/**
|
||||
* @mainpage OpenBeOS Header Documentation
|
||||
*
|
||||
* @section Introduction
|
||||
* This is the header documentation as produced with doxygen. Anyone can
|
||||
* produce this using the doxygen tool and doing this
|
||||
* <pre>
|
||||
* cd docs
|
||||
* doxygen doxygen.conf
|
||||
* </pre>
|
||||
* The resulting files will be produced in dox/html.
|
||||
*
|
||||
* @section Updating
|
||||
* I will attempt to keep these up to date, but if they're not, just
|
||||
* give me a nudge!
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file kernel/OS.h
|
||||
* @brief Definitions, prototypes needed throughout the OS
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup OpenBeOS_Headers OpenBeOS System Headers
|
||||
* @brief Headers that are available for applications
|
||||
*/
|
||||
|
||||
#include <ktypes.h>
|
||||
// ToDo: has to be included here, but does currently causes compiler errors
|
||||
@@ -38,95 +13,40 @@
|
||||
// ToDo: is automatically included by SupportDefs.h, so that one can be removed later
|
||||
#include <Errors.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @defgroup Sys_Consts Constants
|
||||
* @ingroup OpenBeOS_Headers
|
||||
* @brief Constants defined by the system headers
|
||||
* @note these are prefixed B_ for compatability with BeOS
|
||||
* @{
|
||||
*/
|
||||
/**
|
||||
* @def B_OS_NAME_LENGTH
|
||||
* the maximum length of names applied to various structures
|
||||
* for example the maximum length of a thread name supplied in
|
||||
* a spawn_thread() call is determined by this value
|
||||
*/
|
||||
/**
|
||||
* @def B_PAGE_SIZE
|
||||
*size of a single page of memory.
|
||||
* @note this is also the smallest area that can be requested
|
||||
*/
|
||||
/*-------------------------------------------------------------*/
|
||||
/* System constants */
|
||||
|
||||
#define B_OS_NAME_LENGTH 32
|
||||
#define B_PAGE_SIZE 4096
|
||||
#define B_OS_NAME_LENGTH 32
|
||||
#define B_PAGE_SIZE 4096
|
||||
#define B_INFINITE_TIMEOUT (9223372036854775807LL)
|
||||
|
||||
/** @def B_CAN_INTERRUPT
|
||||
* if set the call can be interrupted
|
||||
*/
|
||||
/** @def B_DO_NOT_RESCHEDULE
|
||||
* explanation reqd
|
||||
*/
|
||||
/** @def B_CHECK_PERMISSION
|
||||
* when set the ownership will be checked, and if permission
|
||||
* is not available then the call will fail.
|
||||
*/
|
||||
/** @def B_TIMEOUT
|
||||
* there is a timeout given in this call
|
||||
*/
|
||||
/** @def B_RELATIVE_TIMEOUT
|
||||
* the timeout given in this call is relative to the time now
|
||||
*/
|
||||
/** @def B_ABSOLUTE_TIMEOUT
|
||||
* the timeout given in this call is a time that the timeout will expire
|
||||
*/
|
||||
#define B_CAN_INTERRUPT 1
|
||||
#define B_DO_NOT_RESCHEDULE 2
|
||||
#define B_CHECK_PERMISSION 4
|
||||
#define B_TIMEOUT 8
|
||||
#define B_RELATIVE_TIMEOUT 8
|
||||
#define B_ABSOLUTE_TIMEOUT 16
|
||||
enum {
|
||||
B_TIMEOUT = 8, /* relative timeout */
|
||||
B_RELATIVE_TIMEOUT = 8, /* fails after a relative timeout with B_WOULD_BLOCK */
|
||||
B_ABSOLUTE_TIMEOUT = 16, /* fails after an absolute timeout with B_WOULD BLOCK */
|
||||
};
|
||||
|
||||
/** @} */
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Types */
|
||||
|
||||
/**
|
||||
* @defgroup Sys_types Types
|
||||
* @ingroup OpenBeOS_Headers
|
||||
* @brief Definitions of basic system types.
|
||||
* @note these are not in sys/types.h as they are specific to
|
||||
* this system
|
||||
* @note these are global to the system.
|
||||
* @{
|
||||
*/
|
||||
typedef int32 area_id;
|
||||
typedef int32 port_id;
|
||||
typedef int32 sem_id;
|
||||
typedef int32 team_id;
|
||||
typedef int32 thread_id;
|
||||
|
||||
/**
|
||||
* @typedef area_id
|
||||
* id of an area
|
||||
*/
|
||||
|
||||
typedef int32 area_id;
|
||||
|
||||
/** @} */
|
||||
|
||||
/**
|
||||
* @defgroup Areas Memory Areas
|
||||
* @brief memory areas
|
||||
* @ingroup OpenBeOS_Headers
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Areas */
|
||||
/**
|
||||
* @struct area_info
|
||||
* gives details about a particular area
|
||||
*/
|
||||
|
||||
typedef struct area_info {
|
||||
area_id area;
|
||||
char name[B_OS_NAME_LENGTH];
|
||||
int foo;
|
||||
size_t size;
|
||||
uint32 lock;
|
||||
uint32 protection;
|
||||
@@ -138,25 +58,47 @@ typedef struct area_info {
|
||||
void *address;
|
||||
} area_info;
|
||||
|
||||
/* area locking */
|
||||
#define B_NO_LOCK 0
|
||||
#define B_LAZY_LOCK 1
|
||||
#define B_FULL_LOCK 2
|
||||
#define B_CONTIGUOUS 3
|
||||
#define B_LOMEM 4
|
||||
|
||||
/* address spec for create_area(), and clone_area() */
|
||||
#define B_ANY_ADDRESS 0
|
||||
#define B_EXACT_ADDRESS 1
|
||||
#define B_BASE_ADDRESS 2
|
||||
#define B_CLONE_ADDRESS 3
|
||||
#define B_ANY_KERNEL_ADDRESS 4
|
||||
|
||||
/* area protection */
|
||||
#define B_READ_AREA 1
|
||||
#define B_WRITE_AREA 2
|
||||
|
||||
extern area_id create_area(const char *name, void **start_addr, uint32 addr_spec,
|
||||
size_t size, uint32 lock, uint32 protection);
|
||||
extern area_id clone_area(const char *name, void **dest_addr, uint32 addr_spec,
|
||||
uint32 protection, area_id source);
|
||||
extern area_id find_area(const char *name);
|
||||
extern area_id area_for(void *address);
|
||||
extern status_t delete_area(area_id id);
|
||||
extern status_t resize_area(area_id id, size_t new_size);
|
||||
extern status_t set_area_protection(area_id id, uint32 new_protection);
|
||||
|
||||
/* system private, use macros instead */
|
||||
extern status_t _get_area_info(area_id id, area_info *areaInfo, size_t size);
|
||||
extern status_t _get_next_area_info(team_id team, int32 *cookie, area_info *areaInfo, size_t size);
|
||||
|
||||
#define get_area_info(id, ainfo) \
|
||||
_get_area_info((id), (ainfo),sizeof(*(ainfo)))
|
||||
_get_area_info((id), (ainfo),sizeof(*(ainfo)))
|
||||
#define get_next_area_info(team, cookie, ainfo) \
|
||||
_get_next_area_info((team), (cookie), (ainfo), sizeof(*(ainfo)))
|
||||
_get_next_area_info((team), (cookie), (ainfo), sizeof(*(ainfo)))
|
||||
|
||||
/** @} */
|
||||
|
||||
/**
|
||||
* @defgroup Ports Messaging Ports
|
||||
* @brief A system wide messaging system
|
||||
* @ingroup OpenBeOS_Headers
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Ports */
|
||||
/**
|
||||
* @struct port_info
|
||||
* details about a port, including ownership
|
||||
*/
|
||||
|
||||
typedef struct port_info {
|
||||
port_id port;
|
||||
team_id team;
|
||||
@@ -166,43 +108,36 @@ typedef struct port_info {
|
||||
int32 total_count; /* total # msgs read so far */
|
||||
} port_info;
|
||||
|
||||
port_id create_port(int32, const char *);
|
||||
port_id find_port(const char *);
|
||||
status_t read_port(port_id, int32 *, void *, size_t);
|
||||
status_t read_port_etc(port_id, int32 *, void *, size_t, uint32, bigtime_t);
|
||||
status_t write_port(port_id, int32, const void *, size_t);
|
||||
status_t write_port_etc(port_id, int32, const void *, size_t, uint32, bigtime_t);
|
||||
status_t close_port(port_id port);
|
||||
status_t delete_port(port_id port);
|
||||
extern port_id create_port(int32 capacity, const char *name);
|
||||
extern port_id find_port(const char *name);
|
||||
extern status_t read_port(port_id port, int32 *code, void *buffer, size_t bufferSize);
|
||||
extern status_t read_port_etc(port_id port, int32 *code, void *buffer, size_t bufferSize,
|
||||
uint32 flags, bigtime_t timeout);
|
||||
extern status_t write_port(port_id port, int32 code, const void *buffer, size_t bufferSize);
|
||||
extern status_t write_port_etc(port_id port, int32 code, const void *buffer, size_t bufferSize,
|
||||
uint32 flags, bigtime_t timeout);
|
||||
extern status_t close_port(port_id port);
|
||||
extern status_t delete_port(port_id port);
|
||||
|
||||
ssize_t port_buffer_size(port_id);
|
||||
ssize_t port_buffer_size_etc(port_id, uint32, bigtime_t);
|
||||
ssize_t port_count(port_id);
|
||||
status_t set_port_owner(port_id, team_id);
|
||||
extern ssize_t port_buffer_size(port_id port);
|
||||
extern ssize_t port_buffer_size_etc(port_id port, uint32 flags, bigtime_t timeout);
|
||||
extern ssize_t port_count(port_id port);
|
||||
extern status_t set_port_owner(port_id port, team_id team);
|
||||
|
||||
status_t _get_port_info(port_id, port_info *, size_t);
|
||||
status_t _get_next_port_info(team_id, int32 *, port_info *, size_t);
|
||||
/* system private, use the macros instead */
|
||||
extern status_t _get_port_info(port_id port, port_info *portInfo, size_t portInfoSize);
|
||||
extern status_t _get_next_port_info(team_id team, int32 *cookie, port_info *portInfo,
|
||||
size_t portInfoSize);
|
||||
|
||||
#define get_port_info(port, info) \
|
||||
_get_port_info((port), (info), sizeof(*(info)))
|
||||
|
||||
#define get_next_port_info(team, cookie, info) \
|
||||
_get_next_port_info((team), (cookie), (info), sizeof(*(info)))
|
||||
|
||||
/** @} */
|
||||
|
||||
/**
|
||||
* @defgroup Sems Semaphores
|
||||
* @brief used to provide synchronisation between threads
|
||||
* @ingroup OpenBeOS_Headers
|
||||
* @{
|
||||
*/
|
||||
#define get_port_info(port, info) \
|
||||
_get_port_info((port), (info), sizeof(*(info)))
|
||||
#define get_next_port_info(team, cookie, info) \
|
||||
_get_next_port_info((team), (cookie), (info), sizeof(*(info)))
|
||||
|
||||
|
||||
/**
|
||||
* @struct sem_info
|
||||
* information on a semaphore
|
||||
*/
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Semaphores */
|
||||
|
||||
typedef struct sem_info {
|
||||
sem_id sem;
|
||||
team_id team;
|
||||
@@ -211,107 +146,38 @@ typedef struct sem_info {
|
||||
thread_id latest_holder;
|
||||
} sem_info;
|
||||
|
||||
sem_id create_sem_etc(int32 count, const char *name, team_id owner); /* not public BeOS */
|
||||
sem_id create_sem(int32 count, const char *name);
|
||||
status_t delete_sem(sem_id id);
|
||||
status_t delete_sem_etc(sem_id id, status_t return_code); /* not public BeOS */
|
||||
status_t acquire_sem(sem_id id);
|
||||
status_t acquire_sem_etc(sem_id id, int32 count, uint32 flags, bigtime_t timeout);
|
||||
status_t release_sem(sem_id id);
|
||||
status_t release_sem_etc(sem_id id, int32 count, uint32 flags);
|
||||
status_t get_sem_count(sem_id id, int32* thread_count);
|
||||
status_t _get_sem_info(sem_id id, struct sem_info *info, size_t);
|
||||
status_t _get_next_sem_info(team_id team, int32 *cookie, struct sem_info *info, size_t);
|
||||
status_t set_sem_owner(sem_id id, team_id team);
|
||||
/* semaphore flags */
|
||||
enum {
|
||||
B_CAN_INTERRUPT = 1, /* acquisition of the semaphore can be interrupted (system use only) */
|
||||
B_DO_NOT_RESCHEDULE = 2, /* thread is not rescheduled after release_sem_etc() */
|
||||
B_CHECK_PERMISSION = 4, /* ownership will be checked (system use only) */
|
||||
};
|
||||
|
||||
#define get_sem_info(sem, info) \
|
||||
_get_sem_info((sem), (info), sizeof(*(info)))
|
||||
|
||||
#define get_next_sem_info(team, cookie, info) \
|
||||
_get_next_sem_info((team), (cookie), (info), sizeof(*(info)))
|
||||
extern sem_id create_sem(int32 count, const char *name);
|
||||
extern status_t delete_sem(sem_id id);
|
||||
extern status_t delete_sem_etc(sem_id id, status_t returnCode); /* ToDo: not public BeOS */
|
||||
extern status_t acquire_sem(sem_id id);
|
||||
extern status_t acquire_sem_etc(sem_id id, int32 count, uint32 flags, bigtime_t timeout);
|
||||
extern status_t release_sem(sem_id id);
|
||||
extern status_t release_sem_etc(sem_id id, int32 count, uint32 flags);
|
||||
extern status_t get_sem_count(sem_id id, int32 *threadCount);
|
||||
extern status_t set_sem_owner(sem_id id, team_id team);
|
||||
|
||||
/** @} */
|
||||
/* system private, use the macros instead */
|
||||
extern status_t _get_sem_info(sem_id id, struct sem_info *info, size_t infoSize);
|
||||
extern status_t _get_next_sem_info(team_id team, int32 *cookie, struct sem_info *info,
|
||||
size_t infoSize);
|
||||
|
||||
/**
|
||||
* @defgroup Threads Threads
|
||||
* @brief a distinct, independantly executing task belong to a team
|
||||
* @ingroup OpenBeOS_Headers
|
||||
* @{
|
||||
*/
|
||||
#define get_sem_info(sem, info) \
|
||||
_get_sem_info((sem), (info), sizeof(*(info)))
|
||||
|
||||
/* Threads */
|
||||
#define get_next_sem_info(team, cookie, info) \
|
||||
_get_next_sem_info((team), (cookie), (info), sizeof(*(info)))
|
||||
|
||||
//enum {
|
||||
// THREAD_STATE_READY = 0, // ready to run
|
||||
// THREAD_STATE_RUNNING, // running right now somewhere
|
||||
// THREAD_STATE_WAITING, // blocked on something
|
||||
// THREAD_STATE_SUSPENDED, // suspended, not in queue
|
||||
// THREAD_STATE_FREE_ON_RESCHED, // free the thread structure upon reschedule
|
||||
// THREAD_STATE_BIRTH // thread is being created
|
||||
//};
|
||||
|
||||
typedef enum {
|
||||
B_THREAD_RUNNING=1,
|
||||
B_THREAD_READY,
|
||||
B_THREAD_RECEIVING,
|
||||
B_THREAD_ASLEEP,
|
||||
B_THREAD_SUSPENDED,
|
||||
B_THREAD_WAITING
|
||||
} thread_state;
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Teams */
|
||||
|
||||
/*
|
||||
#define THREAD_IDLE_PRIORITY 0
|
||||
|
||||
#define THREAD_NUM_PRIORITY_LEVELS 64
|
||||
#define THREAD_MIN_PRIORITY (THREAD_IDLE_PRIORITY + 1)
|
||||
#define THREAD_MAX_PRIORITY (THREAD_NUM_PRIORITY_LEVELS - THREAD_NUM_RT_PRIORITY_LEVELS - 1)
|
||||
|
||||
#define THREAD_NUM_RT_PRIORITY_LEVELS 16
|
||||
#define THREAD_MIN_RT_PRIORITY (THREAD_MAX_PRIORITY + 1)
|
||||
#define THREAD_MAX_RT_PRIORITY (THREAD_NUM_PRIORITY_LEVELS - 1)
|
||||
|
||||
#define THREAD_LOWEST_PRIORITY THREAD_MIN_PRIORITY
|
||||
#define THREAD_LOW_PRIORITY 12
|
||||
#define THREAD_MEDIUM_PRIORITY 24
|
||||
#define THREAD_HIGH_PRIORITY 36
|
||||
#define THREAD_HIGHEST_PRIORITY THREAD_MAX_PRIORITY
|
||||
|
||||
#define THREAD_RT_LOW_PRIORITY THREAD_MIN_RT_PRIORITY
|
||||
#define THREAD_RT_HIGH_PRIORITY THREAD_MAX_RT_PRIORITY
|
||||
*/
|
||||
|
||||
#define B_IDLE_PRIORITY 0
|
||||
#define B_LOWEST_ACTIVE_PRIORITY 1
|
||||
|
||||
#define B_LOW_PRIORITY 5
|
||||
#define B_NORMAL_PRIORITY 10
|
||||
#define B_DISPLAY_PRIORITY 15
|
||||
#define B_URGENT_DISPLAY_PRIORITY 20
|
||||
#define B_REAL_TIME_DISPLAY_PRIORITY 100
|
||||
#define B_URGENT_PRIORITY 110
|
||||
#define B_REAL_TIME_PRIORITY 120
|
||||
|
||||
#define B_FIRST_REAL_TIME_PRIORITY B_REAL_TIME_DISPLAY_PRIORITY
|
||||
#define B_MIN_PRIORITY B_IDLE_PRIORITY
|
||||
#define B_MAX_PRIORITY B_REAL_TIME_PRIORITY
|
||||
|
||||
/** information on a thread
|
||||
* @note the thread can be in any state
|
||||
*/
|
||||
typedef struct {
|
||||
thread_id thread;
|
||||
team_id team;
|
||||
char name[B_OS_NAME_LENGTH];
|
||||
thread_state state;
|
||||
int32 priority;
|
||||
sem_id sem;
|
||||
bigtime_t user_time;
|
||||
bigtime_t kernel_time;
|
||||
void *stack_base;
|
||||
void *stack_end;
|
||||
} thread_info;
|
||||
|
||||
/** information on a team */
|
||||
typedef struct {
|
||||
team_id team;
|
||||
int32 thread_count;
|
||||
@@ -325,65 +191,342 @@ typedef struct {
|
||||
gid_t gid;
|
||||
} team_info;
|
||||
|
||||
/**
|
||||
* gives information on user and kernel time for a thread
|
||||
*/
|
||||
#define B_SYSTEM_TEAM 2
|
||||
|
||||
extern status_t kill_team(team_id team);
|
||||
/* see also: send_signal() */
|
||||
|
||||
/* system private, use macros instead */
|
||||
extern status_t _get_team_info(team_id id, team_info *info, size_t size);
|
||||
extern status_t _get_next_team_info(int32 *cookie, team_info *info, size_t size);
|
||||
|
||||
#define get_team_info(id, info) \
|
||||
_get_team_info((id), (info), sizeof(*(info)))
|
||||
|
||||
#define get_next_team_info(cookie, info) \
|
||||
_get_next_team_info((cookie), (info), sizeof(*(info)))
|
||||
|
||||
/* team usage info */
|
||||
|
||||
typedef struct {
|
||||
bigtime_t user_time;
|
||||
bigtime_t kernel_time;
|
||||
} team_usage_info;
|
||||
|
||||
/** @typedef thread_func
|
||||
* the prototype for a function passed in a spawn_thread() call is
|
||||
* @code
|
||||
* int32 some_thread_func(void *data)
|
||||
* {
|
||||
* ...
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
/* system private, use macros instead */
|
||||
extern status_t _get_team_usage_info(team_id team, int32 who, team_usage_info *tui, size_t size);
|
||||
|
||||
#define get_team_usage_info(team, who, info) \
|
||||
_get_team_usage_info((team), (who), (info), sizeof(*(info)))
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Threads */
|
||||
|
||||
typedef enum {
|
||||
B_THREAD_RUNNING = 1,
|
||||
B_THREAD_READY,
|
||||
B_THREAD_RECEIVING,
|
||||
B_THREAD_ASLEEP,
|
||||
B_THREAD_SUSPENDED,
|
||||
B_THREAD_WAITING
|
||||
} thread_state;
|
||||
|
||||
typedef struct {
|
||||
thread_id thread;
|
||||
team_id team;
|
||||
char name[B_OS_NAME_LENGTH];
|
||||
thread_state state;
|
||||
int32 priority;
|
||||
sem_id sem;
|
||||
bigtime_t user_time;
|
||||
bigtime_t kernel_time;
|
||||
void *stack_base;
|
||||
void *stack_end;
|
||||
} thread_info;
|
||||
|
||||
#define B_IDLE_PRIORITY 0
|
||||
#define B_LOWEST_ACTIVE_PRIORITY 1
|
||||
#define B_LOW_PRIORITY 5
|
||||
#define B_NORMAL_PRIORITY 10
|
||||
#define B_DISPLAY_PRIORITY 15
|
||||
#define B_URGENT_DISPLAY_PRIORITY 20
|
||||
#define B_REAL_TIME_DISPLAY_PRIORITY 100
|
||||
#define B_URGENT_PRIORITY 110
|
||||
#define B_REAL_TIME_PRIORITY 120
|
||||
|
||||
#define B_FIRST_REAL_TIME_PRIORITY B_REAL_TIME_DISPLAY_PRIORITY
|
||||
#define B_MIN_PRIORITY B_IDLE_PRIORITY
|
||||
#define B_MAX_PRIORITY B_REAL_TIME_PRIORITY
|
||||
|
||||
typedef int32 (*thread_func) (void *);
|
||||
// the equivalent thread_entry has been removed (deprecated)
|
||||
|
||||
/** @fn thread_id spawn_thread(thread_func func, const char *name, int32 priority, void *data)
|
||||
* creates a new thread within a team
|
||||
* @note the new thread will be created in the suspended state and will not run
|
||||
* until a resume_thread() call is issued
|
||||
* @note the maximum length of name is B_OS_NAME_LENGTH characters
|
||||
*/
|
||||
thread_id spawn_thread (thread_func, const char *, int32, void *);
|
||||
status_t kill_thread(thread_id thread);
|
||||
status_t resume_thread(thread_id thread);
|
||||
status_t suspend_thread(thread_id thread);
|
||||
extern thread_id spawn_thread(thread_func, const char *name, int32 priority, void *data);
|
||||
extern status_t kill_thread(thread_id thread);
|
||||
extern status_t resume_thread(thread_id thread);
|
||||
extern status_t suspend_thread(thread_id thread);
|
||||
|
||||
thread_id find_thread(const char *);
|
||||
extern status_t rename_thread(thread_id thread, const char *newName);
|
||||
extern status_t set_thread_priority (thread_id thread, int32 newPriority);
|
||||
extern void exit_thread(status_t status);
|
||||
extern status_t wait_for_thread (thread_id thread, status_t *threadReturnValue);
|
||||
extern status_t on_exit_thread(void (*callback)(void *), void *data);
|
||||
|
||||
status_t send_data(thread_id thread, int32 code, const void *buffer, size_t buffer_size);
|
||||
status_t receive_data(thread_id *sender, void *buffer, size_t buffer_size);
|
||||
bool has_data(thread_id thread);
|
||||
// ToDo: we also need the INTEL static inline here for compatibility (and the _kfind_thread_() function)
|
||||
extern thread_id find_thread(const char *name);
|
||||
|
||||
status_t snooze(bigtime_t);
|
||||
extern status_t send_data(thread_id thread, int32 code, const void *buffer, size_t buffer_size);
|
||||
extern status_t receive_data(thread_id *sender, void *buffer, size_t buffer_size);
|
||||
extern bool has_data(thread_id thread);
|
||||
|
||||
status_t _get_thread_info(thread_id id, thread_info *info, size_t size);
|
||||
status_t _get_next_thread_info(team_id team, int32 *cookie, thread_info *info, size_t size);
|
||||
status_t _get_team_info(team_id id, team_info *info, size_t size);
|
||||
status_t _get_next_team_info(int32 *cookie, team_info *info, size_t size);
|
||||
extern status_t snooze(bigtime_t amount);
|
||||
extern status_t snooze_until(bigtime_t time, int timeBase);
|
||||
|
||||
#define get_thread_info(id, info) \
|
||||
/* system private, use macros instead */
|
||||
extern status_t _get_thread_info(thread_id id, thread_info *info, size_t size);
|
||||
extern status_t _get_next_thread_info(team_id team, int32 *cookie, thread_info *info, size_t size);
|
||||
|
||||
#define get_thread_info(id, info) \
|
||||
_get_thread_info((id), (info), sizeof(*(info)))
|
||||
|
||||
#define get_next_thread_info(team, cookie, info) \
|
||||
#define get_next_thread_info(team, cookie, info) \
|
||||
_get_next_thread_info((team), (cookie), (info), sizeof(*(info)))
|
||||
|
||||
#define get_team_info(id, info) \
|
||||
_get_team_info((id), (info), sizeof(*(info)))
|
||||
|
||||
#define get_next_team_info(cookie, info) \
|
||||
_get_next_team_info((cookie), (info), sizeof(*(info)))
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Time */
|
||||
|
||||
extern uint32 real_time_clock(void);
|
||||
extern void set_real_time_clock(int32 secs_since_jan1_1970);
|
||||
extern bigtime_t real_time_clock_usecs(void);
|
||||
extern status_t set_timezone(char *timezone);
|
||||
extern bigtime_t system_time(void); /* time since booting in microseconds */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Alarm */
|
||||
|
||||
enum {
|
||||
B_ONE_SHOT_ABSOLUTE_ALARM = 1,
|
||||
B_ONE_SHOT_RELATIVE_ALARM,
|
||||
B_PERIODIC_ALARM /* "when" specifies the period */
|
||||
};
|
||||
|
||||
extern bigtime_t set_alarm(bigtime_t when, uint32 flags);
|
||||
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/* Debugger */
|
||||
|
||||
extern void debugger(const char *message);
|
||||
|
||||
/*
|
||||
calling this function with a non-zero value will cause your thread
|
||||
to receive signals for any exceptional conditions that occur (i.e.
|
||||
you'll get SIGSEGV for data access exceptions, SIGFPE for floating
|
||||
point errors, SIGILL for illegal instructions, etc).
|
||||
|
||||
to re-enable the default debugger pass a zero.
|
||||
*/
|
||||
extern const int disable_debugger(int state);
|
||||
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/* System information */
|
||||
|
||||
#if __INTEL__
|
||||
# define B_MAX_CPU_COUNT 8
|
||||
#elif __POWERPC__
|
||||
# define B_MAX_CPU_COUNT 8
|
||||
#endif
|
||||
|
||||
typedef enum cpu_types {
|
||||
// ToDo: add latest models
|
||||
|
||||
/* Motorola/IBM */
|
||||
B_CPU_PPC_601 = 1,
|
||||
B_CPU_PPC_603 = 2,
|
||||
B_CPU_PPC_603e = 3,
|
||||
B_CPU_PPC_604 = 4,
|
||||
B_CPU_PPC_604e = 5,
|
||||
B_CPU_PPC_750 = 6,
|
||||
B_CPU_PPC_686 = 13,
|
||||
|
||||
/* Intel */
|
||||
B_CPU_INTEL_X86 = 0x1000,
|
||||
B_CPU_INTEL_PENTIUM = 0x1051,
|
||||
B_CPU_INTEL_PENTIUM75,
|
||||
B_CPU_INTEL_PENTIUM_486_OVERDRIVE,
|
||||
B_CPU_INTEL_PENTIUM_MMX,
|
||||
B_CPU_INTEL_PENTIUM_MMX_MODEL_4 = B_CPU_INTEL_PENTIUM_MMX,
|
||||
B_CPU_INTEL_PENTIUM_MMX_MODEL_8 = 0x1058,
|
||||
B_CPU_INTEL_PENTIUM75_486_OVERDRIVE,
|
||||
B_CPU_INTEL_PENTIUM_PRO = 0x1061,
|
||||
B_CPU_INTEL_PENTIUM_II = 0x1063,
|
||||
B_CPU_INTEL_PENTIUM_II_MODEL_3 = 0x1063,
|
||||
B_CPU_INTEL_PENTIUM_II_MODEL_5 = 0x1065,
|
||||
B_CPU_INTEL_CELERON = 0x1066,
|
||||
B_CPU_INTEL_PENTIUM_III = 0x1067,
|
||||
B_CPU_INTEL_PENTIUM_III_MODEL_8 = 0x1068,
|
||||
|
||||
/* AMD */
|
||||
B_CPU_AMD_X86 = 0x1100,
|
||||
B_CPU_AMD_K5_MODEL0 = 0x1150,
|
||||
B_CPU_AMD_K5_MODEL1,
|
||||
B_CPU_AMD_K5_MODEL2,
|
||||
B_CPU_AMD_K5_MODEL3,
|
||||
B_CPU_AMD_K6_MODEL6 = 0x1156,
|
||||
B_CPU_AMD_K6_MODEL7 = 0x1157,
|
||||
B_CPU_AMD_K6_MODEL8 = 0x1158,
|
||||
B_CPU_AMD_K6_2 = 0x1158,
|
||||
B_CPU_AMD_K6_MODEL9 = 0x1159,
|
||||
B_CPU_AMD_K6_III = 0x1159,
|
||||
|
||||
B_CPU_AMD_ATHLON_MODEL1 = 0x1161,
|
||||
|
||||
/* VIA */
|
||||
B_CPU_CYRIX_X86 = 0x1200,
|
||||
B_CPU_CYRIX_GXm = 0x1254,
|
||||
B_CPU_CYRIX_6x86MX = 0x1260,
|
||||
|
||||
/* others */
|
||||
B_CPU_IDT_X86 = 0x1300,
|
||||
B_CPU_IDT_WINCHIP_C6 = 0x1354,
|
||||
B_CPU_IDT_WINCHIP_2 = 0x1358,
|
||||
|
||||
B_CPU_RISE_X86 = 0x1400,
|
||||
B_CPU_RISE_mP6 = 0x1450,
|
||||
|
||||
/* For compatibility */
|
||||
B_CPU_AMD_29K = 14,
|
||||
B_CPU_X86,
|
||||
B_CPU_MC6502,
|
||||
B_CPU_Z80,
|
||||
B_CPU_ALPHA,
|
||||
B_CPU_MIPS,
|
||||
B_CPU_HPPA,
|
||||
B_CPU_M68K,
|
||||
B_CPU_ARM,
|
||||
B_CPU_SH,
|
||||
B_CPU_SPARC,
|
||||
} cpu_type;
|
||||
|
||||
#define B_CPU_X86_VENDOR_MASK 0x1F00
|
||||
|
||||
#ifdef __INTEL__
|
||||
typedef union {
|
||||
struct {
|
||||
uint32 max_eax;
|
||||
char vendorid[12];
|
||||
} eax_0;
|
||||
|
||||
struct {
|
||||
uint32 stepping : 4;
|
||||
uint32 model : 4;
|
||||
uint32 family : 4;
|
||||
uint32 type : 2;
|
||||
uint32 reserved_0 : 18;
|
||||
|
||||
uint32 reserved_1;
|
||||
uint32 features;
|
||||
uint32 reserved_2;
|
||||
} eax_1;
|
||||
|
||||
struct {
|
||||
uint8 call_num;
|
||||
uint8 cache_descriptors[15];
|
||||
} eax_2;
|
||||
|
||||
struct {
|
||||
uint32 reserved[2];
|
||||
uint32 serial_number_high;
|
||||
uint32 serial_number_low;
|
||||
} eax_3;
|
||||
|
||||
char as_chars[16];
|
||||
|
||||
struct {
|
||||
uint32 eax;
|
||||
uint32 ebx;
|
||||
uint32 edx;
|
||||
uint32 ecx;
|
||||
} regs;
|
||||
} cpuid_info;
|
||||
|
||||
extern status_t get_cpuid(cpuid_info* info, uint32 eax_register, uint32 cpu_num);
|
||||
#endif
|
||||
|
||||
|
||||
typedef enum platform_types {
|
||||
B_BEBOX_PLATFORM = 0,
|
||||
B_MAC_PLATFORM,
|
||||
B_AT_CLONE_PLATFORM,
|
||||
B_ENIAC_PLATFORM,
|
||||
B_APPLE_II_PLATFORM,
|
||||
B_CRAY_PLATFORM,
|
||||
B_LISA_PLATFORM,
|
||||
B_TI_994A_PLATFORM,
|
||||
B_TIMEX_SINCLAIR_PLATFORM,
|
||||
B_ORAC_1_PLATFORM,
|
||||
B_HAL_PLATFORM,
|
||||
B_BESM_6_PLATFORM,
|
||||
B_MK_61_PLATFORM,
|
||||
B_NINTENDO_64_PLATFORM
|
||||
} platform_type;
|
||||
|
||||
typedef struct {
|
||||
bigtime_t active_time; /* usec of doing useful work since boot */
|
||||
} cpu_info;
|
||||
|
||||
|
||||
typedef int32 machine_id[2]; /* unique machine ID */
|
||||
|
||||
typedef struct {
|
||||
machine_id id; /* unique machine ID */
|
||||
bigtime_t boot_time; /* time of boot (usecs since 1/1/1970) */
|
||||
|
||||
int32 cpu_count; /* number of cpus */
|
||||
enum cpu_types cpu_type; /* type of cpu */
|
||||
int32 cpu_revision; /* revision # of cpu */
|
||||
cpu_info cpu_infos[B_MAX_CPU_COUNT]; /* info about individual cpus */
|
||||
int64 cpu_clock_speed; /* processor clock speed (Hz) */
|
||||
int64 bus_clock_speed; /* bus clock speed (Hz) */
|
||||
enum platform_types platform_type; /* type of machine we're on */
|
||||
|
||||
int32 max_pages; /* total # physical pages */
|
||||
int32 used_pages; /* # physical pages in use */
|
||||
int32 page_faults; /* # of page faults */
|
||||
int32 max_sems;
|
||||
int32 used_sems;
|
||||
int32 max_ports;
|
||||
int32 used_ports;
|
||||
int32 max_threads;
|
||||
int32 used_threads;
|
||||
int32 max_teams;
|
||||
int32 used_teams;
|
||||
|
||||
// ToDo: B_FILE_NAME_LENGTH is currently not defined at this point
|
||||
// char kernel_name[B_FILE_NAME_LENGTH]; /* name of kernel */
|
||||
char kernel_name[256];
|
||||
char kernel_build_date[B_OS_NAME_LENGTH]; /* date kernel built */
|
||||
char kernel_build_time[B_OS_NAME_LENGTH]; /* time kernel built */
|
||||
int64 kernel_version; /* version of this kernel */
|
||||
|
||||
bigtime_t _busy_wait_time; /* reserved for Be */
|
||||
int32 pad[4]; /* just in case... */
|
||||
} system_info;
|
||||
|
||||
/* system private, use macro instead */
|
||||
extern status_t _get_system_info (system_info *returned_info, size_t size);
|
||||
|
||||
#define get_system_info(info) \
|
||||
_get_system_info((info), sizeof(*(info)))
|
||||
|
||||
extern int32 is_computer_on(void);
|
||||
extern double is_computer_on_fire(void);
|
||||
|
||||
/** @} */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _OS_H */
|
||||
|
||||
|
||||
+11
-14
@@ -38,19 +38,19 @@ typedef enum {
|
||||
} image_type;
|
||||
|
||||
typedef struct {
|
||||
image_id id;
|
||||
image_type type;
|
||||
int32 sequence;
|
||||
int32 init_order;
|
||||
image_id id;
|
||||
image_type type;
|
||||
int32 sequence;
|
||||
int32 init_order;
|
||||
void (*init_routine)();
|
||||
void (*term_routine)();
|
||||
dev_t device;
|
||||
dev_t device;
|
||||
ino_t node;
|
||||
char name[MAXPATHLEN];
|
||||
void *text;
|
||||
char name[MAXPATHLEN];
|
||||
void *text;
|
||||
void *data;
|
||||
int32 text_size;
|
||||
int32 data_size;
|
||||
int32 text_size;
|
||||
int32 data_size;
|
||||
} image_info;
|
||||
|
||||
extern _IMPEXP_ROOT thread_id load_image(int32 argc, const char **argv,
|
||||
@@ -87,7 +87,7 @@ extern _IMPEXP_ROOT status_t get_nth_image_symbol(image_id imid, int32 index,
|
||||
/*---------------------------------------------------------*/
|
||||
/*----- cache manipulation --------------------------------*/
|
||||
|
||||
#define B_FLUSH_DCACHE 0x0001 /* dcache = data cache */
|
||||
#define B_FLUSH_DCACHE 0x0001 /* dcache = data cache */
|
||||
#define B_FLUSH_ICACHE 0x0004 /* icache = instruction cache */
|
||||
#define B_INVALIDATE_DCACHE 0x0002
|
||||
#define B_INVALIDATE_ICACHE 0x0008
|
||||
@@ -100,7 +100,4 @@ extern _IMPEXP_ROOT void clear_caches(void *addr, size_t len, uint32 flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/*-------------------------------------------------------------*/
|
||||
|
||||
#endif /* _IMAGE_H */
|
||||
#endif /* _IMAGE_H */
|
||||
|
||||
Reference in New Issue
Block a user