278 lines
9 KiB
C
278 lines
9 KiB
C
#ifndef __KERNEL_H_LOADED
|
|
#define __KERNEL_H_LOADED
|
|
/*****************************************************************************
|
|
|
|
Copyright © 1993, 1994 Digital Equipment Corporation,
|
|
Maynard, Massachusetts.
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted, provided
|
|
that the copyright notice and this permission notice appear in all copies
|
|
of software and supporting documentation, and that the name of Digital not
|
|
be used in advertising or publicity pertaining to distribution of the software
|
|
without specific, written prior permission. Digital grants this permission
|
|
provided that you prominently mark, as not part of the original, any
|
|
modifications made to this software or documentation.
|
|
|
|
Digital Equipment Corporation disclaims all warranties and/or guarantees
|
|
with regard to this software, including all implied warranties of fitness for
|
|
a particular purpose and merchantability, and makes no representations
|
|
regarding the use of, or the results of the use of, the software and
|
|
documentation in terms of correctness, accuracy, reliability, currentness or
|
|
otherwise; and you rely on the software, documentation and results solely at
|
|
your own risk.
|
|
|
|
******************************************************************************/
|
|
|
|
/*
|
|
* $Id: kernel.h,v 1.1.1.1 1997/10/30 23:27:16 verghese Exp $;
|
|
*/
|
|
|
|
/*
|
|
* Derived from EB64 version; history of EB64 version:
|
|
*
|
|
* $Log: kernel.h,v $
|
|
* Revision 1.1.1.1 1997/10/30 23:27:16 verghese
|
|
* current 10/29/97
|
|
*
|
|
* Revision 1.7 1994/08/05 20:13:47 fdh
|
|
* Updated Copyright header and RCS $Id: identifier.
|
|
*
|
|
* Revision 1.6 1994/06/28 20:08:21 fdh
|
|
* Modified filenames and build precedure to fit into a FAT filesystem.
|
|
*
|
|
* Revision 1.5 1994/06/20 14:18:59 fdh
|
|
* Fixup header file preprocessor #include conditionals.
|
|
*
|
|
* Revision 1.4 1994/03/09 12:48:33 berent
|
|
* Made NT compilable and tidied up
|
|
*
|
|
* Revision 1.4 1993/10/01 15:47:00 berent
|
|
* Added saved_user_pc; used to avoid need for special ethernet PAL code
|
|
*
|
|
* Revision 1.3 1993/08/09 11:43:38 berent
|
|
* Correct return types of some functions
|
|
*
|
|
* Revision 1.2 1993/06/08 22:32:06 berent
|
|
* Changed to improve ladbx server communications
|
|
*
|
|
* Revision 1.1 1993/06/08 19:56:36 fdh
|
|
* Initial revision
|
|
*
|
|
*/
|
|
|
|
#include "system.h"
|
|
#include "server_t.h"
|
|
|
|
|
|
/* kload_implemented - check whether the kernel will load new processes.
|
|
*
|
|
* Returns TRUE if this kernel supports the loading of new processes,
|
|
* FALSE if not.
|
|
*/
|
|
extern kload_implemented(void);
|
|
|
|
/* kload - load a new process.
|
|
*
|
|
* Arguments:
|
|
* name - file name of new process.
|
|
* argv - argument array for new process, NULL terminated.
|
|
* standardIn - file name of standard input.
|
|
* standardOut - file name of standard output.
|
|
* standardError - file name of standard error.
|
|
* loadAddress - address at which client expects process to be loaded; or
|
|
* all bits 1 if unknown.
|
|
* startAddress - address at which client expects process to start executing.
|
|
* ignored if the load address is not set.
|
|
*
|
|
* The format and interpretation of file name arguments is kernel dependent except
|
|
* in that an empty string always means use the default (if any). The
|
|
* standard input, standard output and standard error file names may be ignored by
|
|
* some kernels. Kernels will only use the load and start addresses if they have
|
|
* direct control over where programs are loaded or started.
|
|
*
|
|
* Return Value:
|
|
* TRUE if successful, FALSE if not.
|
|
*/
|
|
extern int kload(char * name,
|
|
char * argv[],
|
|
char * standardIn,
|
|
char * standardOut,
|
|
char * standardError,
|
|
address_value loadAddress,
|
|
address_value startAddress);
|
|
|
|
/* kconnect_implemented - check whether the kernel will connect to existing processes.
|
|
*
|
|
* Returns TRUE if this kernel supports connecting to existing processes,
|
|
* FALSE if not.
|
|
*/
|
|
|
|
extern int kconnect_implemented(void);
|
|
|
|
/* kconnect - connect to an existing process
|
|
*
|
|
* Argument:
|
|
* pid - process id of process to which the kernel is to be connected. The interpretation
|
|
* of this value is kernel dependent. It may be ignored by kernels running
|
|
* in a non multiprocessing environment.
|
|
*
|
|
* Return Value:
|
|
* TRUE if successful, FALSE if not.
|
|
*/
|
|
extern int kconnect(ui pid);
|
|
|
|
/* kkill_possible - checks whether this kernel can kill the current process.
|
|
*
|
|
* Return Value:
|
|
* TRUE if possible; false if not.
|
|
*/
|
|
extern int kkill_possible(void);
|
|
|
|
/* kkill - kill the current process.
|
|
*/
|
|
extern void kkill(void);
|
|
|
|
/* kdetach_possible - checks whether this kernel can detach from the current process
|
|
* without killing it.
|
|
*
|
|
* Return Value:
|
|
* TRUE if possible; false if not.
|
|
*/
|
|
extern int kdetach_possible(void);
|
|
|
|
/* kdetach - detach from the current process without killing it. If possible the kernel will
|
|
* not remove any breakpoints or continue the process if it is stopped ; but
|
|
* there may be kernels on which detaching can only be implemented such that
|
|
* it does one or both of these.
|
|
*/
|
|
extern void kdetach(void);
|
|
|
|
/* kpid - return the pid of the current process.
|
|
*/
|
|
extern ui kpid(void);
|
|
|
|
/* kgo - run the current process until it hits a breakpoint or stops for some
|
|
* other reason.
|
|
*/
|
|
extern void kgo(void);
|
|
|
|
/* kstop - stop the current process as soon as possible.
|
|
*/
|
|
extern void kstop(void);
|
|
|
|
/* kaddressok - check whether an address is readable
|
|
*
|
|
* Argument:
|
|
* address - the address to be checked.
|
|
*
|
|
* Return value:
|
|
* TRUE if readable, FALSE if not.
|
|
*/
|
|
extern int kaddressok(address_value address);
|
|
|
|
/* kcexamine - get a value from memory.
|
|
*
|
|
* Argument:
|
|
* address - the address from which the value is to be fetched. Must be
|
|
* 8 byte alligned.
|
|
*
|
|
* Return value:
|
|
* The 8 byte value at address. If there is a breakpoint within this 8 byte
|
|
* region the value returned is the value that would be at that address if the
|
|
* breakpoint were removed.
|
|
*/
|
|
extern ul kcexamine(address_value address);
|
|
|
|
|
|
/* kcdeposit - deposit a value in memory.
|
|
*
|
|
* Arguments:
|
|
* address - the address at which the value is to be deposited. Must be
|
|
* 8 byte alligned.
|
|
* value - the 8 byte value to be deposited. If there is a breakpoint within
|
|
* the 8 byte region the new value should not overwrite any breakpoint
|
|
* instruction; but instead should change the value that will be written
|
|
* back when any such instruction is removed.
|
|
*
|
|
* Return value:
|
|
* TRUE if successful. FALSE if the kernel was unable to deposit the data.
|
|
*/
|
|
extern int kcdeposit(address_value address, ul value);
|
|
|
|
/* kstep - step one instruction. If there is a breakpoint at the current program counter
|
|
* the instruction that would be at that address if the breakpoint were removed is
|
|
* executed.
|
|
*/
|
|
extern void kstep(void);
|
|
|
|
/* kpc - get the current program counter.
|
|
*
|
|
* Return value:
|
|
* current program counter.
|
|
*/
|
|
extern address_value kpc(void);
|
|
|
|
/* ksetpc - update the program counter.
|
|
*
|
|
* Argument:
|
|
* address - new value of program counter.
|
|
*/
|
|
extern void ksetpc(address_value address);
|
|
|
|
/* kregister - get the contents of a register
|
|
*
|
|
* Argument:
|
|
* reg - the register number. If reg is in the range 0 to 31 the function fetches the
|
|
* contents of fixed point register reg. If reg is the range 32 to 63 it
|
|
* fetches (as an 8 byte bit pattern) the contents of floating point register
|
|
* reg-32.
|
|
*
|
|
* Return value:
|
|
* The 8 byte bit pattern in the selected register.
|
|
*/
|
|
extern register_value kregister(int reg);
|
|
|
|
/* ksetreg - writes a bit pattern to a register
|
|
*
|
|
* Arguments:
|
|
* reg - the register number, as for kregister.
|
|
* value - the 8 byte bit pattern to be written.
|
|
*/
|
|
extern void ksetreg(int reg, register_value value);
|
|
|
|
/* kbreak - sets a breakpoint.
|
|
*
|
|
* Argument:
|
|
* address - the address at which a breakpoint is to be set. Must be 4 byte alligned.
|
|
*
|
|
* Return value:
|
|
* The result that should be sent back to the client.
|
|
*/
|
|
extern short int kbreak(address_value address);
|
|
|
|
/* kremovebreak - sets a breakpoint.
|
|
*
|
|
* Argument:
|
|
* address - the address of the breakpoint. Must be 4 byte alligned.
|
|
*
|
|
* Return value:
|
|
* The result that should be sent back to the client.
|
|
*/
|
|
extern short int kremovebreak(address_value address);
|
|
|
|
/* kpoll - get the state of the current process.
|
|
*
|
|
* Return value:
|
|
* PROCESS_STATE_PROCESS_RUNNING - the process is running,
|
|
* PROCESS_STATE_PROCESS_AT_BREAK - the process has stopped at a breakpoint,
|
|
* PROCESS_STATE_PROCESS_SUSPENDED - the process has stopped elsewhere,
|
|
* PROCESS_STATE_PROCESS_TERMINATED - the process no longer exists,
|
|
* PROCESS_STATE_PROCESS_LOADING - the process is loading,
|
|
* PROCESS_STATE_LOAD_FAILED - the process failed to load.
|
|
*/
|
|
extern int kpoll(void);
|
|
|
|
#endif /* __KERNEL_H_LOADED */
|