paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-26 20:03:49 +02:00
Code Issues Packages Projects Releases Wiki Activity
1682586b08
fpc/rtl/beos/beos.inc
marco 97533b60f8 * Small fixes and quick merge with 1.0.x. At least the compiler builds now, 
but it could crash hard, since there are lots of unimplemented funcs.
2003-01-08 22:32:28 +00:00

572 lines
16 KiB
PHP
Raw Blame History

{
$Id$
Copyright (c) 2001 by Carl Eric Codere
Implements BeOS system calls and types
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
****************************************************************************
}
const
{ BeOS specific calls }
syscall_nr_create_area = $14;
syscall_nr_resize_area = $08;
syscall_nr_delete_area = $15;
syscall_nr_load_image = $34;
syscall_nr_wait_thread = $22;
syscall_nr_rstat = $30;
syscall_nr_statfs = $5F;
syscall_nr_get_team_info = $3b;
syscall_nr_kill_team = $3a;
syscall_nr_get_system_info = $56;
syscall_nr_kget_tzfilename = $AF;
syscall_nr_get_next_image_info = $3C;
const
{ -----
system-wide constants;
----- *}
MAXPATHLEN = PATH_MAX;
B_FILE_NAME_LENGTH = NAME_MAX;
B_OS_NAME_LENGTH = 32;
B_PAGE_SIZE = 4096;
(* -----
types
----- *)
type area_id = longint;
type port_id = longint;
type sem_id = longint;
type thread_id = longint;
type team_id = longint;
type bigtime_t = int64;
type status_t = longint;
{*************************************************************}
{*********************** KERNEL KIT **************************}
{*************************************************************}
{ ------------------------- Areas --------------------------- }
const
{ create_area constant definitions }
{ lock type }
B_NO_LOCK = 0;
B_LAZY_LOCK = 1;
B_FULL_LOCK = 2;
B_CONTIGUOUS = 3;
B_LOMEM = 4;
{ address type }
B_ANY_ADDRESS = 0;
B_EXACT_ADDRESS = 1;
B_BASE_ADDRESS = 2;
B_CLONE_ADDRESS = 3;
B_ANY_KERNEL_ADDRESS = 4;
{ protection bits }
B_READ_AREA = 1;
B_WRITE_AREA = 2;
type
area_info = packed record
area: area_id;
name: array[0..B_OS_NAME_LENGTH-1] of char;
size: size_t;
lock: cardinal;
protection: cardinal;
team: team_id;
ram_size: cardinal;
copy_count: cardinal;
in_count: cardinal;
out_count: cardinal;
address: pointer;
end;
function create_area(name : pchar; var addr : longint;
addr_typ : longint; size : longint; lock_type: longint; protection : longint): area_id;
var
args : SysCallArgs;
begin
args.param[1] := cint(name);
args.param[2] := cint(@addr);
args.param[3] := cint(addr_typ);
args.param[4] := cint(size);
args.param[5] := cint(lock_type);
args.param[6] := cint(protection);
create_area := SysCall(syscall_nr_create_area, args);
end;
function delete_area(area : area_id): status_t;
var
args: SysCallargs;
begin
args.param[1] := cint(area);
delete_area:= SysCall(syscall_nr_delete_area, args);
end;
function resize_area(area: area_id; new_size: size_t): status_t;
var
args: SysCallArgs;
begin
args.param[1] := cint(area);
args.param[2] := cint(new_size);
resize_area := SysCall(syscall_nr_resize_area, args);
end;
{ the buffer should at least have MAXPATHLEN+1 bytes in size }
function kget_tzfilename(buffer:pchar): cint;
var
args: SysCallArgs;
begin
args.param[1] := cint(buffer);
kget_tzfilename := SysCall(syscall_nr_kget_tzfilename,args);
end;
(*
extern _IMPEXP_ROOT area_id clone_area(const char *name, void **dest_addr,
uint32 addr_spec, uint32 protection,
area_id source);
extern _IMPEXP_ROOT area_id find_area(const char *name);
extern _IMPEXP_ROOT area_id area_for(void *addr);
extern _IMPEXP_ROOT status_t set_area_protection(area_id id,
uint32 new_protection);
extern _IMPEXP_ROOT status_t _get_area_info(area_id id, area_info *ainfo,
size_t size);
extern _IMPEXP_ROOT status_t _get_next_area_info(team_id team, int32 *cookie,
area_info *ainfo, size_t size);
*)
{ ------------------------- Threads --------------------------- }
const
{ thread state }
B_THREAD_RUNNING = 1;
B_THREAD_READY = 2;
B_THREAD_RECEIVING = 3;
B_THREAD_ASLEEP = 4;
B_THREAD_SUSPENDED = 5;
B_THREAD_WAITING = 6;
{ thread priorities }
B_LOW_PRIORITY = 5;
B_NORMAL_PRIORITY = 10;
B_DISPLAY_PRIORITY = 15;
B_URGENT_DISPLAY_PRIORITY = 20;
B_REAL_TIME_DISPLAY_PRIORITY= 100;
B_URGENT_PRIORITY = 110;
B_REAL_TIME_PRIORITY = 120;
type
thread_info = packed record
thread: thread_id;
team: team_id;
name: array[0..B_OS_NAME_LENGTH-1] of char;
state: longint; { thread_state enum }
priority:longint;
sem:sem_id;
user_time:bigtime_t;
kernel_time:bigtime_t;
stack_base:pointer;
stack_end:pointer;
end;
{
extern _IMPEXP_ROOT thread_id spawn_thread (
thread_func function_name,
const char *thread_name,
int32 priority,
void *arg
);
extern _IMPEXP_ROOT thread_id find_thread(const char *name);
extern _IMPEXP_ROOT status_t kill_thread(thread_id thread);
extern _IMPEXP_ROOT status_t resume_thread(thread_id thread);
extern _IMPEXP_ROOT status_t suspend_thread(thread_id thread);
extern _IMPEXP_ROOT status_t rename_thread(thread_id thread, const char *new_name);
extern _IMPEXP_ROOT status_t set_thread_priority (thread_id thread, int32 new_priority);
extern _IMPEXP_ROOT void exit_thread(status_t status);
extern _IMPEXP_ROOT status_t _get_thread_info(thread_id thread, thread_info *info, size_t size);
extern _IMPEXP_ROOT status_t _get_next_thread_info(team_id tmid, int32 *cookie, thread_info *info, size_t size);
extern _IMPEXP_ROOT status_t send_data(thread_id thread,
int32 code,
const void *buf,
size_t buffer_size);
extern _IMPEXP_ROOT status_t receive_data(thread_id *sender,
void *buf,
size_t buffer_size);
extern _IMPEXP_ROOT bool has_data(thread_id thread);
extern _IMPEXP_ROOT status_t snooze(bigtime_t microseconds);
/*
Right now you can only snooze_until() on a single time base, the
system time base given by system_time(). The "time" argument is
the time (in the future) relative to the current system_time() that
you want to snooze until. Eventually there will be multiple time
bases (and a way to find out which ones exist) but for now just pass
the value B_SYSTEM_TIMEBASE.
*/
extern _IMPEXP_ROOT status_t snooze_until(bigtime_t time, int timebase);
#define B_SYSTEM_TIMEBASE (0)
}
function wait_for_thread(thread: thread_id; var status : status_t): status_t;
var
args: SysCallArgs;
i: longint;
begin
args.param[1] := cint(thread);
args.param[2] := cint(@status);
wait_for_thread := SysCall(syscall_nr_wait_thread, args);
end;
{ ------------------------- Teams --------------------------- }
const
B_SYSTEM_TEAM = 2;
type
team_info = packed record
team: team_id;
image_count: longint;
thread_count: longint;
area_count: longint;
debugger_nub_thread: thread_id;
debugger_nub_port: port_id;
argc:longint; (* number of args on the command line *)
args: array[0..63] of char; {* abbreviated command line args *}
uid: uid_t;
gid: gid_t;
end;
{
extern _IMPEXP_ROOT status_t _get_next_team_info(int32 *cookie, team_info *info, size_t size);
}
function get_team_info(team: team_id; var info : team_info): status_t;
var
args: SysCallArgs;
begin
args.param[1] := cint(team);
args.param[2] := cint(@info);
get_team_info := SysCall(syscall_nr_get_team_info, args);
end;
function kill_team(team: team_id): status_t;
var
args: SysCallArgs;
begin
args.param[1] := cint(team);
kill_team := SysCall(syscall_nr_kill_team, args);
end;
{ ------------------------- Images --------------------------- }
type image_id = longint;
{ image types }
const
B_APP_IMAGE = 1;
B_LIBRARY_IMAGE = 2;
B_ADD_ON_IMAGE = 3;
B_SYSTEM_IMAGE = 4;
type
image_info = packed record
id : image_id;
_type : longint;
sequence: longint;
init_order: longint;
init_routine: pointer;
term_routine: pointer;
device: dev_t;
node: ino_t;
name: array[0..MAXPATHLEN-1] of char;
text: pointer;
data: pointer;
text_size: longint;
data_size: longint;
end;
function get_next_image_info(team : team_id; var cookie: longint;var info : image_info): status_t;
var
args: SysCallArgs;
begin
args.param[1] := cint(team);
args.param[2] := cint(@cookie);
args.param[3] := cint(@info);
args.param[4] := cint(sizeof(image_info));
get_next_image_info := SysCall(syscall_nr_get_next_image_info, args);
end;
{
extern _IMPEXP_ROOT image_id load_add_on(const char *path);
extern _IMPEXP_ROOT status_t unload_add_on(image_id imid);
/* private; use the macros, below */
extern _IMPEXP_ROOT status_t _get_image_info (image_id image,
image_info *info, size_t size);
extern _IMPEXP_ROOT status_t _get_next_image_info (team_id team, int32 *cookie,
image_info *info, size_t size);
}
(*----- symbol types and functions ------------------------*)
const B_SYMBOL_TYPE_DATA = $1;
const B_SYMBOL_TYPE_TEXT = $2;
const B_SYMBOL_TYPE_ANY = $5;
{
extern _IMPEXP_ROOT status_t get_image_symbol(image_id imid,
const char *name, int32 sclass, void **ptr);
extern _IMPEXP_ROOT status_t get_nth_image_symbol(image_id imid, int32 index,
char *buf, int32 *bufsize, int32 *sclass,
void **ptr);
}
{*----- cache manipulation --------------------------------*}
const
B_FLUSH_DCACHE =$0001; {* dcache = data cache *}
B_FLUSH_ICACHE =$0004; {* icache = instruction cache *}
B_INVALIDATE_DCACHE =$0002;
B_INVALIDATE_ICACHE =$0008;
{
extern _IMPEXP_ROOT void clear_caches(void *addr, size_t len, uint32 flags);
}
function load_image(argc : longint; argv : ppchar; envp : ppchar): thread_id;
var
args: SysCallArgs;
i: longint;
begin
args.param[1] := cint(argc);
args.param[2] := cint(argv);
args.param[3] := cint(envp);
load_image := SysCall(syscall_nr_load_image, args);
end;
{ ------------------------ System information --------------------------- }
{ for both intel and ppc platforms }
const B_MAX_CPU_COUNT = 8;
type
system_info = packed record
id: array[0..1] of longint; {* unique machine ID *}
boot_time: bigtime_t; {* time of boot (# usec since 1/1/70) *}
cpu_count: longint; {* # of cpus *}
cpu_type: longint; {* type of cpu *}
cpu_revision:longint ; {* revision # of cpu *}
cpu_infos: array [0..B_MAX_CPU_COUNT-1] of bigtime_t; {* info about individual cpus *}
cpu_clock_speed:int64; {* processor clock speed (Hz) *}
bus_clock_speed:int64; {* bus clock speed (Hz) * }
platform_type:longint; {* type of machine we're on *}
max_pages:longint; {* total # physical pages *}
used_pages:longint; {* # physical pages in use *}
page_faults:longint; {* # of page faults *}
max_sems:longint; {* maximum # semaphores *}
used_sems:longint; {* # semaphores in use *}
max_ports:longint; {* maximum # ports *}
used_ports:longint; {* # ports in use *}
max_threads:longint; {* maximum # threads *}
used_threads:longint; {* # threads in use *}
max_teams:longint; {* maximum # teams *}
used_teams:longint; {* # teams in use *}
kernel_name: array[0..B_FILE_NAME_LENGTH-1] of char; {* name of kernel *}
kernel_build_date: array[0..B_OS_NAME_LENGTH-1] of char; {* date kernel built *}
kernel_build_time: array[0..B_OS_NAME_LENGTH-1] of char; {* time kernel built *}
kernel_version:int64; {* version of this kernel *}
_busy_wait_time:bigtime_t; {* reserved for Be *}
pad:array[1..4] of longint; {* just in case... *}
end;
function get_system_info(var info: system_info): status_t;
var
args: SysCallArgs;
i: longint;
begin
args.param[1] := cint(@info);
i := SysCall(syscall_nr_get_system_info, args);
get_system_info := i;
end;
{*************************************************************}
{*********************** STORAGE KIT *************************}
{*************************************************************}
const
{ file system flags }
B_FS_IS_READONLY = $00000001;
B_FS_IS_REMOVABLE = $00000002;
B_FS_IS_PERSISTENT = $00000004;
B_FS_IS_SHARED = $00000008;
B_FS_HAS_MIME = $00010000;
B_FS_HAS_ATTR = $00020000;
B_FS_HAS_QUERY = $00040000;
type
fs_info = packed record
dev : dev_t; { fs dev_t }
root : ino_t; { root ino_t }
flags : cardinal; { file system flags }
block_size:off_t; { fundamental block size }
io_size:off_t; { optimal io size }
total_blocks:off_t; { total number of blocks }
free_blocks:off_t; { number of free blocks }
total_nodes:off_t; { total number of nodes }
free_nodes:off_t; { number of free nodes }
device_name: array[0..127] of char; { device holding fs }
volume_name: array[0..B_FILE_NAME_LENGTH-1] of char;{ volume name }
fsh_name : array[0..B_OS_NAME_LENGTH-1] of char;{ name of fs handler }
end;
function dev_for_path(const pathname : pchar): dev_t;
var
args: SysCallArgs;
buffer: array[1..15] of longint;
i: cint;
begin
args.param[1] := $FFFFFFFF;
args.param[2] := cint(pathname);
args.param[3] := cint(@buffer);
args.param[4] := $01000000;
if SysCall(syscall_nr_rstat, args)=0 then
i:=buffer[1]
else
i:=-1;
dev_for_path := i;
end;
function fs_stat_dev(device: dev_t; var info: fs_info): dev_t;
var
args: SysCallArgs;
begin
args.param[1] := cint(device);
args.param[2] := 0;
args.param[3] := $FFFFFFFF;
args.param[4] := 0;
args.param[5] := cint(@info);
fs_stat_dev := SysCall(syscall_nr_statfs, args);
end;
{
_IMPEXP_ROOT dev_t next_dev(int32 *pos);
}
{*****************************************************************}
{
$Log$
Revision 1.2 2003-01-08 22:32:28 marco
* Small fixes and quick merge with 1.0.x. At least the compiler builds now,
but it could crash hard, since there are lots of unimplemented funcs.
Revision 1.1.2.6 2002/02/15 18:15:00 carl
+ added get_next_image_info
Revision 1.1.2.5 2001/08/13 05:56:35 carl
* renamed routine names (names are same as documented in the Be Book)
Revision 1.1.2.4 2001/08/12 15:14:24 carl
+ added kget_tzfilename() kernel call to get timezone info.
Revision 1.1.2.3 2001/08/04 06:14:15 carl
- remove crappy tab characters
Revision 1.1.2.2 2001/08/04 05:25:03 carl
+ added much more system headers and system calls
Revision 1.1.2.1 2001/08/03 01:57:36 carl
* beos types and system inteface (minimalistic for the moment)
}
Reference in New Issue View Git Blame Copy Permalink