retire _PROTOTYPE
. only good for obsolete K&R support . also remove a stray ansi.h and the proto cmd
This commit is contained in:
Ben Gras
@@ -6,16 +6,6 @@
|
||||
* of the rules. (For consistency with the new '#ifdef _ANSI" tests in
|
||||
* the headers, _ANSI should really be defined as nothing, but that would
|
||||
* break many library routines that use "#if _ANSI".)
|
||||
|
||||
* If _ANSI ends up being defined, a macro
|
||||
*
|
||||
* _PROTOTYPE(function, params)
|
||||
*
|
||||
* is defined. This macro expands in different ways, generating either
|
||||
* ANSI Standard C prototypes or old-style K&R (Kernighan & Ritchie)
|
||||
* prototypes, as needed. Finally, some programs use _CONST, _VOIDSTAR etc
|
||||
* in such a way that they are portable over both ANSI and K&R compilers.
|
||||
* The appropriate macros are defined here.
|
||||
*/
|
||||
|
||||
#ifndef _MINIX_ANSI_H
|
||||
@@ -34,8 +24,6 @@
|
||||
|
||||
#ifdef _ANSI
|
||||
|
||||
/* Keep everything for ANSI prototypes. */
|
||||
#define _PROTOTYPE(function, params) function params
|
||||
#define _ARGS(params) params
|
||||
|
||||
#define _CONST const
|
||||
@@ -44,8 +32,6 @@
|
||||
|
||||
#else
|
||||
|
||||
/* Throw away the parameters for K&R prototypes. */
|
||||
#define _PROTOTYPE(function, params) function()
|
||||
#define _ARGS(params) ()
|
||||
|
||||
#define _CONST
|
||||
|
||||
@@ -6,20 +6,20 @@
|
||||
#include <sys/ioc_sound.h>
|
||||
|
||||
|
||||
_PROTOTYPE( int drv_init, (void) );
|
||||
_PROTOTYPE( int drv_init_hw, (void) );
|
||||
_PROTOTYPE( int drv_reset, (void) );
|
||||
_PROTOTYPE( int drv_start, (int sub_dev, int DmaMode) );
|
||||
_PROTOTYPE( int drv_stop, (int sub_dev) );
|
||||
_PROTOTYPE( int drv_set_dma, (u32_t dma, u32_t length, int chan) );
|
||||
_PROTOTYPE( int drv_reenable_int, (int chan) );
|
||||
_PROTOTYPE( int drv_int_sum, (void) );
|
||||
_PROTOTYPE( int drv_int, (int sub_dev) );
|
||||
_PROTOTYPE( int drv_pause, (int chan) );
|
||||
_PROTOTYPE( int drv_resume, (int chan) );
|
||||
_PROTOTYPE( int drv_io_ctl, (int request, void * val, int * len, int sub_dev) );
|
||||
_PROTOTYPE( int drv_get_irq, (char *irq) );
|
||||
_PROTOTYPE( int drv_get_frag_size, (u32_t *frag_size, int sub_dev) );
|
||||
int drv_init(void);
|
||||
int drv_init_hw(void);
|
||||
int drv_reset(void);
|
||||
int drv_start(int sub_dev, int DmaMode);
|
||||
int drv_stop(int sub_dev);
|
||||
int drv_set_dma(u32_t dma, u32_t length, int chan);
|
||||
int drv_reenable_int(int chan);
|
||||
int drv_int_sum(void);
|
||||
int drv_int(int sub_dev);
|
||||
int drv_pause(int chan);
|
||||
int drv_resume(int chan);
|
||||
int drv_io_ctl(int request, void * val, int * len, int sub_dev);
|
||||
int drv_get_irq(char *irq);
|
||||
int drv_get_frag_size(u32_t *frag_size, int sub_dev);
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -15,25 +15,25 @@ typedef enum {
|
||||
/* Entry points into the device dependent code of block drivers. */
|
||||
struct blockdriver {
|
||||
blockdriver_type_t bdr_type;
|
||||
_PROTOTYPE( int (*bdr_open), (dev_t minor, int access) );
|
||||
_PROTOTYPE( int (*bdr_close), (dev_t minor) );
|
||||
_PROTOTYPE( ssize_t (*bdr_transfer), (dev_t minor, int do_write, u64_t pos,
|
||||
endpoint_t endpt, iovec_t *iov, unsigned count, int flags) );
|
||||
_PROTOTYPE( int (*bdr_ioctl), (dev_t minor, unsigned int request,
|
||||
endpoint_t endpt, cp_grant_id_t grant) );
|
||||
_PROTOTYPE( void (*bdr_cleanup), (void) );
|
||||
_PROTOTYPE( struct device *(*bdr_part), (dev_t minor) );
|
||||
_PROTOTYPE( void (*bdr_geometry), (dev_t minor, struct partition *part) );
|
||||
_PROTOTYPE( void (*bdr_intr), (unsigned int irqs) );
|
||||
_PROTOTYPE( void (*bdr_alarm), (clock_t stamp) );
|
||||
_PROTOTYPE( int (*bdr_other), (message *m_ptr) );
|
||||
_PROTOTYPE( int (*bdr_device), (dev_t minor, device_id_t *id) );
|
||||
int(*bdr_open) (dev_t minor, int access);
|
||||
int(*bdr_close) (dev_t minor);
|
||||
ssize_t(*bdr_transfer) (dev_t minor, int do_write, u64_t pos,
|
||||
endpoint_t endpt, iovec_t *iov, unsigned count, int flags);
|
||||
int(*bdr_ioctl) (dev_t minor, unsigned int request, endpoint_t endpt,
|
||||
cp_grant_id_t grant);
|
||||
void(*bdr_cleanup) (void);
|
||||
struct device *(*bdr_part)(dev_t minor);
|
||||
void(*bdr_geometry) (dev_t minor, struct partition *part);
|
||||
void(*bdr_intr) (unsigned int irqs);
|
||||
void(*bdr_alarm) (clock_t stamp);
|
||||
int(*bdr_other) (message *m_ptr);
|
||||
int(*bdr_device) (dev_t minor, device_id_t *id);
|
||||
};
|
||||
|
||||
/* Functions defined by libblockdriver. These can be used for both
|
||||
* singlethreaded and multithreaded drivers.
|
||||
*/
|
||||
_PROTOTYPE( void blockdriver_announce, (int type) );
|
||||
void blockdriver_announce(int type);
|
||||
|
||||
#ifndef _BLOCKDRIVER_MT_API
|
||||
/* Additional functions for the singlethreaded version. These allow the driver
|
||||
@@ -41,12 +41,12 @@ _PROTOTYPE( void blockdriver_announce, (int type) );
|
||||
* To avoid accidents, these functions are not exposed when minix/driver_mt.h
|
||||
* has been included previously.
|
||||
*/
|
||||
_PROTOTYPE( int blockdriver_receive_mq, (message *m_ptr, int *status_ptr) );
|
||||
_PROTOTYPE( void blockdriver_process, (struct blockdriver *dp, message *m_ptr,
|
||||
int ipc_status) );
|
||||
_PROTOTYPE( void blockdriver_terminate, (void) );
|
||||
_PROTOTYPE( void blockdriver_task, (struct blockdriver *bdp) );
|
||||
_PROTOTYPE( int blockdriver_mq_queue, (message *m_ptr, int status) );
|
||||
int blockdriver_receive_mq(message *m_ptr, int *status_ptr);
|
||||
void blockdriver_process(struct blockdriver *dp, message *m_ptr, int
|
||||
ipc_status);
|
||||
void blockdriver_terminate(void);
|
||||
void blockdriver_task(struct blockdriver *bdp);
|
||||
int blockdriver_mq_queue(message *m_ptr, int status);
|
||||
#endif /* !_BLOCKDRIVER_MT_API */
|
||||
|
||||
/* Parameters for the disk drive. */
|
||||
|
||||
@@ -4,11 +4,11 @@
|
||||
#define BLOCKDRIVER_MT_API 1 /* do not expose the singlethreaded API */
|
||||
#include <minix/blockdriver.h>
|
||||
|
||||
_PROTOTYPE( void blockdriver_mt_task, (struct blockdriver *driver_tab) );
|
||||
_PROTOTYPE( void blockdriver_mt_sleep, (void) );
|
||||
_PROTOTYPE( void blockdriver_mt_wakeup, (thread_id_t id) );
|
||||
_PROTOTYPE( void blockdriver_mt_terminate, (void) );
|
||||
_PROTOTYPE( void blockdriver_mt_set_workers, (device_id_t id, int workers) );
|
||||
_PROTOTYPE( thread_id_t blockdriver_mt_get_tid, (void) );
|
||||
void blockdriver_mt_task(struct blockdriver *driver_tab);
|
||||
void blockdriver_mt_sleep(void);
|
||||
void blockdriver_mt_wakeup(thread_id_t id);
|
||||
void blockdriver_mt_terminate(void);
|
||||
void blockdriver_mt_set_workers(device_id_t id, int workers);
|
||||
thread_id_t blockdriver_mt_get_tid(void);
|
||||
|
||||
#endif /* _MINIX_BLOCKDRIVER_MT_H */
|
||||
|
||||
@@ -5,18 +5,18 @@
|
||||
|
||||
/* Entry points into the device dependent code of character drivers. */
|
||||
struct chardriver {
|
||||
_PROTOTYPE( int (*cdr_open), (message *m_ptr) );
|
||||
_PROTOTYPE( int (*cdr_close), (message *m_ptr) );
|
||||
_PROTOTYPE( int (*cdr_ioctl), (message *m_ptr) );
|
||||
_PROTOTYPE( struct device *(*cdr_prepare), (dev_t device) );
|
||||
_PROTOTYPE( int (*cdr_transfer), (endpoint_t endpt, int opcode,
|
||||
u64_t position, iovec_t *iov, unsigned int nr_req,
|
||||
endpoint_t user_endpt, unsigned int flags) );
|
||||
_PROTOTYPE( void (*cdr_cleanup), (void) );
|
||||
_PROTOTYPE( void (*cdr_alarm), (message *m_ptr) );
|
||||
_PROTOTYPE( int (*cdr_cancel), (message *m_ptr) );
|
||||
_PROTOTYPE( int (*cdr_select), (message *m_ptr) );
|
||||
_PROTOTYPE( int (*cdr_other), (message *m_ptr) );
|
||||
int(*cdr_open) (message *m_ptr);
|
||||
int(*cdr_close) (message *m_ptr);
|
||||
int(*cdr_ioctl) (message *m_ptr);
|
||||
struct device *(*cdr_prepare)(dev_t device);
|
||||
int(*cdr_transfer) (endpoint_t endpt, int opcode, u64_t position,
|
||||
iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
|
||||
flags);
|
||||
void(*cdr_cleanup) (void);
|
||||
void(*cdr_alarm) (message *m_ptr);
|
||||
int(*cdr_cancel) (message *m_ptr);
|
||||
int(*cdr_select) (message *m_ptr);
|
||||
int(*cdr_other) (message *m_ptr);
|
||||
};
|
||||
|
||||
#define CHARDRIVER_SYNC 0 /* use the synchronous protocol */
|
||||
@@ -25,17 +25,17 @@ struct chardriver {
|
||||
#define IS_CDEV_MINOR_RQ(type) (IS_DEV_RQ(type) && (type) != DEV_STATUS)
|
||||
|
||||
/* Functions defined by libchardriver. */
|
||||
_PROTOTYPE( void chardriver_announce, (void) );
|
||||
_PROTOTYPE( void chardriver_process, (struct chardriver *cdp, int driver_type,
|
||||
message *m_ptr, int ipc_status) );
|
||||
_PROTOTYPE( void chardriver_terminate, (void) );
|
||||
_PROTOTYPE( void chardriver_task, (struct chardriver *cdp, int driver_type) );
|
||||
void chardriver_announce(void);
|
||||
void chardriver_process(struct chardriver *cdp, int driver_type, message
|
||||
*m_ptr, int ipc_status);
|
||||
void chardriver_terminate(void);
|
||||
void chardriver_task(struct chardriver *cdp, int driver_type);
|
||||
|
||||
_PROTOTYPE( int do_nop, (message *m_ptr) );
|
||||
_PROTOTYPE( void nop_cleanup, (void) );
|
||||
_PROTOTYPE( void nop_alarm, (message *m_ptr) );
|
||||
_PROTOTYPE( int nop_cancel, (message *m_ptr) );
|
||||
_PROTOTYPE( int nop_select, (message *m_ptr) );
|
||||
_PROTOTYPE( int nop_ioctl, (message *m_ptr) );
|
||||
int do_nop(message *m_ptr);
|
||||
void nop_cleanup(void);
|
||||
void nop_alarm(message *m_ptr);
|
||||
int nop_cancel(message *m_ptr);
|
||||
int nop_select(message *m_ptr);
|
||||
int nop_ioctl(message *m_ptr);
|
||||
|
||||
#endif /* _MINIX_CHARDRIVER_H */
|
||||
|
||||
@@ -21,6 +21,6 @@
|
||||
#define _CPUF_I386_HTT 13 /* Supports HTT */
|
||||
#define _CPUF_I386_HTT_MAX_NUM 14 /* Maximal num of threads */
|
||||
|
||||
_PROTOTYPE(int _cpufeature, (int featureno));
|
||||
int _cpufeature(int featureno);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -3,6 +3,6 @@
|
||||
#ifndef _MINIX_CRTSO_H
|
||||
#define _MINIX_CRTSO_H
|
||||
|
||||
_PROTOTYPE( void _minix_unmapzero, (void));
|
||||
void _minix_unmapzero(void);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -56,16 +56,16 @@ struct devman_usb_dev {
|
||||
|
||||
typedef int (*devman_usb_bind_cb_t)(struct devman_usb_bind_cb_data *data, endpoint_t ep);
|
||||
|
||||
_PROTOTYPE( int devman_add_device, (struct devman_dev *dev));
|
||||
_PROTOTYPE( int devman_del_device, (struct devman_dev *dev));
|
||||
_PROTOTYPE( int devman_init, (void));
|
||||
_PROTOTYPE( struct devman_usb_dev* devman_usb_device_new, (int dev_id));
|
||||
_PROTOTYPE( int devman_usb_device_add, (struct devman_usb_dev *dev));
|
||||
_PROTOTYPE( int devman_usb_device_remove, (struct devman_usb_dev *dev));
|
||||
_PROTOTYPE( void devman_usb_device_delete, (struct devman_usb_dev *udev));
|
||||
_PROTOTYPE( int devman_handle_msg, (message *m));
|
||||
_PROTOTYPE( void devman_usb_init, (devman_usb_bind_cb_t bind_cb,
|
||||
devman_usb_bind_cb_t unbind_cb) );
|
||||
int devman_add_device(struct devman_dev *dev);
|
||||
int devman_del_device(struct devman_dev *dev);
|
||||
int devman_init(void);
|
||||
struct devman_usb_dev* devman_usb_device_new(int dev_id);
|
||||
int devman_usb_device_add(struct devman_usb_dev *dev);
|
||||
int devman_usb_device_remove(struct devman_usb_dev *dev);
|
||||
void devman_usb_device_delete(struct devman_usb_dev *udev);
|
||||
int devman_handle_msg(message *m);
|
||||
void devman_usb_init(devman_usb_bind_cb_t bind_cb, devman_usb_bind_cb_t
|
||||
unbind_cb);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -4,8 +4,8 @@
|
||||
|
||||
#include <machine/partition.h>
|
||||
|
||||
_PROTOTYPE( void partition, (struct blockdriver *bdr, int device, int style,
|
||||
int atapi) );
|
||||
void partition(struct blockdriver *bdr, int device, int style, int
|
||||
atapi);
|
||||
|
||||
#define DEV_PER_DRIVE (1 + NR_PARTITIONS)
|
||||
#define MINOR_t0 64
|
||||
|
||||
@@ -37,41 +37,39 @@
|
||||
/* ds.c */
|
||||
|
||||
/* U32 */
|
||||
_PROTOTYPE( int ds_publish_u32, (const char *name, u32_t val, int flags));
|
||||
_PROTOTYPE( int ds_retrieve_u32, (const char *name, u32_t *val));
|
||||
_PROTOTYPE( int ds_delete_u32, (const char *ds_name));
|
||||
int ds_publish_u32(const char *name, u32_t val, int flags);
|
||||
int ds_retrieve_u32(const char *name, u32_t *val);
|
||||
int ds_delete_u32(const char *ds_name);
|
||||
|
||||
/* STRING */
|
||||
_PROTOTYPE( int ds_publish_str, (const char *name, char *val, int flags));
|
||||
_PROTOTYPE( int ds_retrieve_str, (const char *name, char *val, size_t len));
|
||||
_PROTOTYPE( int ds_delete_str, (const char *ds_name));
|
||||
int ds_publish_str(const char *name, char *val, int flags);
|
||||
int ds_retrieve_str(const char *name, char *val, size_t len);
|
||||
int ds_delete_str(const char *ds_name);
|
||||
|
||||
/* MEM */
|
||||
_PROTOTYPE( int ds_publish_mem, (const char *ds_name, void *vaddr,
|
||||
size_t length, int flags));
|
||||
_PROTOTYPE( int ds_retrieve_mem, (const char *ds_name, char *vaddr,
|
||||
size_t *length));
|
||||
_PROTOTYPE( int ds_delete_mem, (const char *ds_name));
|
||||
int ds_publish_mem(const char *ds_name, void *vaddr, size_t length, int
|
||||
flags);
|
||||
int ds_retrieve_mem(const char *ds_name, char *vaddr, size_t *length);
|
||||
int ds_delete_mem(const char *ds_name);
|
||||
|
||||
/* MAP */
|
||||
_PROTOTYPE( int ds_publish_map, (const char *ds_name, void *vaddr,
|
||||
size_t length, int flags));
|
||||
_PROTOTYPE( int ds_snapshot_map, (const char *ds_name, int *nr_snapshot));
|
||||
_PROTOTYPE( int ds_retrieve_map, (const char *ds_name, char *vaddr,
|
||||
size_t *length, int nr_snapshot, int flags));
|
||||
_PROTOTYPE( int ds_delete_map, (const char *ds_name));
|
||||
int ds_publish_map(const char *ds_name, void *vaddr, size_t length, int
|
||||
flags);
|
||||
int ds_snapshot_map(const char *ds_name, int *nr_snapshot);
|
||||
int ds_retrieve_map(const char *ds_name, char *vaddr, size_t *length,
|
||||
int nr_snapshot, int flags);
|
||||
int ds_delete_map(const char *ds_name);
|
||||
|
||||
/* LABEL */
|
||||
_PROTOTYPE( int ds_publish_label, (const char *ds_name, endpoint_t endpoint,
|
||||
int flags));
|
||||
_PROTOTYPE( int ds_retrieve_label_name, (char *ds_name, endpoint_t endpoint));
|
||||
_PROTOTYPE( int ds_retrieve_label_endpt, (const char *ds_name,
|
||||
endpoint_t *endpoint));
|
||||
_PROTOTYPE( int ds_delete_label, (const char *ds_name));
|
||||
int ds_publish_label(const char *ds_name, endpoint_t endpoint, int
|
||||
flags);
|
||||
int ds_retrieve_label_name(char *ds_name, endpoint_t endpoint);
|
||||
int ds_retrieve_label_endpt(const char *ds_name, endpoint_t *endpoint);
|
||||
int ds_delete_label(const char *ds_name);
|
||||
|
||||
/* Subscribe and check. */
|
||||
_PROTOTYPE( int ds_subscribe, (const char *regex, int flags));
|
||||
_PROTOTYPE( int ds_check, (char *ds_name, int *type, endpoint_t *owner_e));
|
||||
int ds_subscribe(const char *regex, int flags);
|
||||
int ds_check(char *ds_name, int *type, endpoint_t *owner_e);
|
||||
|
||||
#endif /* _MINIX_DS_H */
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
/* V1 and V2 file system disk to/from memory support functions. */
|
||||
|
||||
_PROTOTYPE( int bitmapsize, (bit_t _nr_bits, int block_size) );
|
||||
_PROTOTYPE( unsigned conv2, (int _norm, int _w) );
|
||||
_PROTOTYPE( long conv4, (int _norm, long _x) );
|
||||
_PROTOTYPE( void conv_inode, (struct inode *_rip, d1_inode *_dip,
|
||||
d2_inode *_dip2, int _rw_flag, int _magic) );
|
||||
_PROTOTYPE( void old_icopy, (struct inode *_rip, d1_inode *_dip,
|
||||
int _direction, int _norm));
|
||||
_PROTOTYPE( void new_icopy, (struct inode *_rip, d2_inode *_dip,
|
||||
int _direction, int _norm));
|
||||
int bitmapsize(bit_t _nr_bits, int block_size);
|
||||
unsigned conv2(int _norm, int _w);
|
||||
long conv4(int _norm, long _x);
|
||||
void conv_inode(struct inode *_rip, d1_inode *_dip, d2_inode *_dip2, int
|
||||
_rw_flag, int _magic);
|
||||
void old_icopy(struct inode *_rip, d1_inode *_dip, int _direction, int
|
||||
_norm);
|
||||
void new_icopy(struct inode *_rip, d2_inode *_dip, int _direction, int
|
||||
_norm);
|
||||
|
||||
@@ -32,35 +32,33 @@ struct hgfs_attr {
|
||||
HGFS_ATTR_MTIME | HGFS_ATTR_CTIME | HGFS_ATTR_MODE | \
|
||||
HGFS_ATTR_ATIME_SET | HGFS_ATTR_MTIME_SET)
|
||||
|
||||
_PROTOTYPE( int hgfs_init, (void) );
|
||||
_PROTOTYPE( void hgfs_cleanup, (void) );
|
||||
int hgfs_init(void);
|
||||
void hgfs_cleanup(void);
|
||||
|
||||
_PROTOTYPE( int hgfs_enabled, (void) );
|
||||
int hgfs_enabled(void);
|
||||
|
||||
_PROTOTYPE( int hgfs_open, (char *path, int flags, int mode,
|
||||
hgfs_file_t *handle) );
|
||||
_PROTOTYPE( int hgfs_read, (hgfs_file_t handle, char *buf, size_t size,
|
||||
u64_t offset) );
|
||||
_PROTOTYPE( int hgfs_write, (hgfs_file_t handle, const char *buf,
|
||||
size_t len, u64_t offset, int append) );
|
||||
_PROTOTYPE( int hgfs_close, (hgfs_file_t handle) );
|
||||
int hgfs_open(char *path, int flags, int mode, hgfs_file_t *handle);
|
||||
int hgfs_read(hgfs_file_t handle, char *buf, size_t size, u64_t offset);
|
||||
int hgfs_write(hgfs_file_t handle, const char *buf, size_t len, u64_t
|
||||
offset, int append);
|
||||
int hgfs_close(hgfs_file_t handle);
|
||||
|
||||
_PROTOTYPE( size_t hgfs_readbuf, (char **ptr) );
|
||||
_PROTOTYPE( size_t hgfs_writebuf, (char **ptr) );
|
||||
size_t hgfs_readbuf(char **ptr);
|
||||
size_t hgfs_writebuf(char **ptr);
|
||||
|
||||
_PROTOTYPE( int hgfs_opendir, (char *path, hgfs_dir_t *handle) );
|
||||
_PROTOTYPE( int hgfs_readdir, (hgfs_dir_t handle, unsigned int index,
|
||||
char *buf, size_t size, struct hgfs_attr *attr) );
|
||||
_PROTOTYPE( int hgfs_closedir, (hgfs_dir_t handle) );
|
||||
int hgfs_opendir(char *path, hgfs_dir_t *handle);
|
||||
int hgfs_readdir(hgfs_dir_t handle, unsigned int index, char *buf,
|
||||
size_t size, struct hgfs_attr *attr);
|
||||
int hgfs_closedir(hgfs_dir_t handle);
|
||||
|
||||
_PROTOTYPE( int hgfs_getattr, (char *path, struct hgfs_attr *attr) );
|
||||
_PROTOTYPE( int hgfs_setattr, (char *path, struct hgfs_attr *attr) );
|
||||
int hgfs_getattr(char *path, struct hgfs_attr *attr);
|
||||
int hgfs_setattr(char *path, struct hgfs_attr *attr);
|
||||
|
||||
_PROTOTYPE( int hgfs_mkdir, (char *path, int mode) );
|
||||
_PROTOTYPE( int hgfs_unlink, (char *path) );
|
||||
_PROTOTYPE( int hgfs_rmdir, (char *path) );
|
||||
_PROTOTYPE( int hgfs_rename, (char *opath, char *npath) );
|
||||
int hgfs_mkdir(char *path, int mode);
|
||||
int hgfs_unlink(char *path);
|
||||
int hgfs_rmdir(char *path);
|
||||
int hgfs_rename(char *opath, char *npath);
|
||||
|
||||
_PROTOTYPE( int hgfs_queryvol, (char *path, u64_t *free, u64_t *total) );
|
||||
int hgfs_queryvol(char *path, u64_t *free, u64_t *total);
|
||||
|
||||
#endif /* _HGFS_H */
|
||||
|
||||
@@ -162,14 +162,14 @@ typedef struct asynmsg
|
||||
#define sendnb _sendnb
|
||||
#define senda _senda
|
||||
|
||||
_PROTOTYPE( int echo, (message *m_ptr) );
|
||||
_PROTOTYPE( int notify, (endpoint_t dest) );
|
||||
_PROTOTYPE( int sendrec, (endpoint_t src_dest, message *m_ptr) );
|
||||
_PROTOTYPE( int receive, (endpoint_t src, message *m_ptr, int *status_ptr));
|
||||
_PROTOTYPE( int send, (endpoint_t dest, message *m_ptr) );
|
||||
_PROTOTYPE( int sendnb, (endpoint_t dest, message *m_ptr) );
|
||||
_PROTOTYPE( int senda, (asynmsg_t *table, size_t count) );
|
||||
int echo(message *m_ptr);
|
||||
int notify(endpoint_t dest);
|
||||
int sendrec(endpoint_t src_dest, message *m_ptr);
|
||||
int receive(endpoint_t src, message *m_ptr, int *status_ptr);
|
||||
int send(endpoint_t dest, message *m_ptr);
|
||||
int sendnb(endpoint_t dest, message *m_ptr);
|
||||
int senda(asynmsg_t *table, size_t count);
|
||||
|
||||
_PROTOTYPE( int _do_kernel_call, (message *m_ptr) );
|
||||
int _do_kernel_call(message *m_ptr);
|
||||
|
||||
#endif /* _IPC_H */
|
||||
|
||||
@@ -6,28 +6,28 @@
|
||||
#endif
|
||||
|
||||
/* Miscellaneous BSD. */
|
||||
_PROTOTYPE(char *itoa, (int _n));
|
||||
char *itoa(int _n);
|
||||
#ifndef __NBSD_LIBC
|
||||
_PROTOTYPE(char *getpass, (const char *_prompt));
|
||||
char *getpass(const char *_prompt);
|
||||
#ifdef __ACK__
|
||||
_PROTOTYPE(void swab, (char *_from, char *_to, int _count));
|
||||
void swab(char *_from, char *_to, int _count);
|
||||
#endif
|
||||
#endif /* !_NBSD_LIBC */
|
||||
|
||||
/* Miscellaneous MINIX. */
|
||||
_PROTOTYPE(void std_err, (const char *_s));
|
||||
_PROTOTYPE(void prints, (const char *_s, ...));
|
||||
_PROTOTYPE(int fsversion, (char *_dev, char *_prog));
|
||||
_PROTOTYPE(int getprocessor, (void));
|
||||
_PROTOTYPE(void _cpuid, (u32_t *eax, u32_t *ebx, u32_t *ecx, u32_t *edx));
|
||||
_PROTOTYPE(int load_mtab, (char *_prog_name));
|
||||
_PROTOTYPE(int rewrite_mtab, (char *_prog_name));
|
||||
_PROTOTYPE(int get_mtab_entry, (char *_s1, char *_s2, char *_s3, char *_s4));
|
||||
_PROTOTYPE(int put_mtab_entry, (char *_s1, char *_s2, char *_s3, char *_s4));
|
||||
void std_err(const char *_s);
|
||||
void prints(const char *_s, ...);
|
||||
int fsversion(char *_dev, char *_prog);
|
||||
int getprocessor(void);
|
||||
void _cpuid(u32_t *eax, u32_t *ebx, u32_t *ecx, u32_t *edx);
|
||||
int load_mtab(char *_prog_name);
|
||||
int rewrite_mtab(char *_prog_name);
|
||||
int get_mtab_entry(char *_s1, char *_s2, char *_s3, char *_s4);
|
||||
int put_mtab_entry(char *_s1, char *_s2, char *_s3, char *_s4);
|
||||
|
||||
/* read_tsc() and friends */
|
||||
_PROTOTYPE(void read_tsc, (u32_t *hi, u32_t *lo));
|
||||
_PROTOTYPE(void read_tsc_64, (u64_t *t));
|
||||
void read_tsc(u32_t *hi, u32_t *lo);
|
||||
void read_tsc_64(u64_t *t);
|
||||
|
||||
/* return values for fsversion */
|
||||
#define FSVERSION_MFS1 0x00001
|
||||
|
||||
@@ -75,82 +75,72 @@ typedef struct {
|
||||
#define MTHREAD_KEYS_MAX 128
|
||||
|
||||
/* allocate.c */
|
||||
_PROTOTYPE( int mthread_create, (mthread_thread_t *thread,
|
||||
mthread_attr_t *tattr,
|
||||
void *(*proc)(void *), void *arg) );
|
||||
_PROTOTYPE( int mthread_detach, (mthread_thread_t thread) );
|
||||
_PROTOTYPE( int mthread_equal, (mthread_thread_t l, mthread_thread_t r) );
|
||||
_PROTOTYPE( void mthread_exit, (void *value) );
|
||||
_PROTOTYPE( int mthread_join, (mthread_thread_t thread, void **value) );
|
||||
_PROTOTYPE( int mthread_once, (mthread_once_t *once,
|
||||
void (*proc)(void)) );
|
||||
_PROTOTYPE( mthread_thread_t mthread_self, (void) );
|
||||
int mthread_create(mthread_thread_t *thread, mthread_attr_t *tattr, void
|
||||
*(*proc)(void *), void *arg);
|
||||
int mthread_detach(mthread_thread_t thread);
|
||||
int mthread_equal(mthread_thread_t l, mthread_thread_t r);
|
||||
void mthread_exit(void *value);
|
||||
int mthread_join(mthread_thread_t thread, void **value);
|
||||
int mthread_once(mthread_once_t *once, void (*proc)(void));
|
||||
mthread_thread_t mthread_self(void);
|
||||
|
||||
/* attribute.c */
|
||||
_PROTOTYPE( int mthread_attr_destroy, (mthread_attr_t *tattr) );
|
||||
_PROTOTYPE( int mthread_attr_getdetachstate, (mthread_attr_t *tattr,
|
||||
int *detachstate) );
|
||||
_PROTOTYPE( int mthread_attr_getstack, (mthread_attr_t *tattr,
|
||||
void **stackaddr,
|
||||
size_t *stacksize) );
|
||||
_PROTOTYPE( int mthread_attr_getstacksize, (mthread_attr_t *tattr,
|
||||
size_t *stacksize) );
|
||||
_PROTOTYPE( int mthread_attr_init, (mthread_attr_t *tattr) );
|
||||
_PROTOTYPE( int mthread_attr_setdetachstate, (mthread_attr_t *tattr,
|
||||
int detachstate) );
|
||||
_PROTOTYPE( int mthread_attr_setstack, (mthread_attr_t *tattr,
|
||||
void *stackaddr,
|
||||
size_t stacksize) );
|
||||
_PROTOTYPE( int mthread_attr_setstacksize, (mthread_attr_t *tattr,
|
||||
size_t stacksize) );
|
||||
int mthread_attr_destroy(mthread_attr_t *tattr);
|
||||
int mthread_attr_getdetachstate(mthread_attr_t *tattr, int
|
||||
*detachstate);
|
||||
int mthread_attr_getstack(mthread_attr_t *tattr, void **stackaddr,
|
||||
size_t *stacksize);
|
||||
int mthread_attr_getstacksize(mthread_attr_t *tattr, size_t *stacksize);
|
||||
int mthread_attr_init(mthread_attr_t *tattr);
|
||||
int mthread_attr_setdetachstate(mthread_attr_t *tattr, int detachstate);
|
||||
int mthread_attr_setstack(mthread_attr_t *tattr, void *stackaddr, size_t
|
||||
stacksize);
|
||||
int mthread_attr_setstacksize(mthread_attr_t *tattr, size_t stacksize);
|
||||
|
||||
|
||||
/* condition.c */
|
||||
_PROTOTYPE( int mthread_cond_broadcast, (mthread_cond_t *cond) );
|
||||
_PROTOTYPE( int mthread_cond_destroy, (mthread_cond_t *cond) );
|
||||
_PROTOTYPE( int mthread_cond_init, (mthread_cond_t *cond,
|
||||
mthread_condattr_t *cattr) );
|
||||
_PROTOTYPE( int mthread_cond_signal, (mthread_cond_t *cond) );
|
||||
_PROTOTYPE( int mthread_cond_wait, (mthread_cond_t *cond,
|
||||
mthread_mutex_t *mutex) );
|
||||
int mthread_cond_broadcast(mthread_cond_t *cond);
|
||||
int mthread_cond_destroy(mthread_cond_t *cond);
|
||||
int mthread_cond_init(mthread_cond_t *cond, mthread_condattr_t *cattr);
|
||||
int mthread_cond_signal(mthread_cond_t *cond);
|
||||
int mthread_cond_wait(mthread_cond_t *cond, mthread_mutex_t *mutex);
|
||||
|
||||
/* key.c */
|
||||
_PROTOTYPE( int mthread_key_create, (mthread_key_t *key,
|
||||
void (*destructor)(void *)) );
|
||||
_PROTOTYPE( int mthread_key_delete, (mthread_key_t key) );
|
||||
_PROTOTYPE( void *mthread_getspecific, (mthread_key_t key) );
|
||||
_PROTOTYPE( int mthread_setspecific, (mthread_key_t key, void *value) );
|
||||
int mthread_key_create(mthread_key_t *key, void (*destructor)(void *));
|
||||
int mthread_key_delete(mthread_key_t key);
|
||||
void *mthread_getspecific(mthread_key_t key);
|
||||
int mthread_setspecific(mthread_key_t key, void *value);
|
||||
|
||||
/* misc.c */
|
||||
_PROTOTYPE( void mthread_stats, (void) );
|
||||
_PROTOTYPE( void mthread_verify_f, (char *f, int l) );
|
||||
void mthread_stats(void);
|
||||
void mthread_verify_f(char *f, int l);
|
||||
#define mthread_verify() mthread_verify_f(__FILE__, __LINE__)
|
||||
|
||||
/* mutex.c */
|
||||
_PROTOTYPE( int mthread_mutex_destroy, (mthread_mutex_t *mutex) );
|
||||
_PROTOTYPE( int mthread_mutex_init, (mthread_mutex_t *mutex,
|
||||
mthread_mutexattr_t *mattr) );
|
||||
_PROTOTYPE( int mthread_mutex_lock, (mthread_mutex_t *mutex) );
|
||||
_PROTOTYPE( int mthread_mutex_trylock, (mthread_mutex_t *mutex) );
|
||||
_PROTOTYPE( int mthread_mutex_unlock, (mthread_mutex_t *mutex) );
|
||||
int mthread_mutex_destroy(mthread_mutex_t *mutex);
|
||||
int mthread_mutex_init(mthread_mutex_t *mutex, mthread_mutexattr_t
|
||||
*mattr);
|
||||
int mthread_mutex_lock(mthread_mutex_t *mutex);
|
||||
int mthread_mutex_trylock(mthread_mutex_t *mutex);
|
||||
int mthread_mutex_unlock(mthread_mutex_t *mutex);
|
||||
|
||||
/* event.c */
|
||||
_PROTOTYPE( int mthread_event_destroy, (mthread_event_t *event) );
|
||||
_PROTOTYPE( int mthread_event_init, (mthread_event_t *event) );
|
||||
_PROTOTYPE( int mthread_event_wait, (mthread_event_t *event) );
|
||||
_PROTOTYPE( int mthread_event_fire, (mthread_event_t *event) );
|
||||
_PROTOTYPE( int mthread_event_fire_all, (mthread_event_t *event));
|
||||
int mthread_event_destroy(mthread_event_t *event);
|
||||
int mthread_event_init(mthread_event_t *event);
|
||||
int mthread_event_wait(mthread_event_t *event);
|
||||
int mthread_event_fire(mthread_event_t *event);
|
||||
int mthread_event_fire_all(mthread_event_t *event);
|
||||
|
||||
/* rwlock.c */
|
||||
_PROTOTYPE( int mthread_rwlock_destroy, (mthread_rwlock_t *rwlock) );
|
||||
_PROTOTYPE( int mthread_rwlock_init, (mthread_rwlock_t *rwlock) );
|
||||
_PROTOTYPE( int mthread_rwlock_rdlock, (mthread_rwlock_t *rwlock) );
|
||||
_PROTOTYPE( int mthread_rwlock_wrlock, (mthread_rwlock_t *rwlock) );
|
||||
_PROTOTYPE( int mthread_rwlock_unlock, (mthread_rwlock_t *rwlock) );
|
||||
int mthread_rwlock_destroy(mthread_rwlock_t *rwlock);
|
||||
int mthread_rwlock_init(mthread_rwlock_t *rwlock);
|
||||
int mthread_rwlock_rdlock(mthread_rwlock_t *rwlock);
|
||||
int mthread_rwlock_wrlock(mthread_rwlock_t *rwlock);
|
||||
int mthread_rwlock_unlock(mthread_rwlock_t *rwlock);
|
||||
|
||||
/* schedule.c */
|
||||
_PROTOTYPE( void mthread_init, (void) );
|
||||
_PROTOTYPE( int mthread_yield, (void) );
|
||||
_PROTOTYPE( void mthread_yield_all, (void) );
|
||||
void mthread_init(void);
|
||||
int mthread_yield(void);
|
||||
void mthread_yield_all(void);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -7,8 +7,7 @@
|
||||
#include <minix/ipc.h>
|
||||
|
||||
/* Functions defined by netdriver.c: */
|
||||
_PROTOTYPE( void netdriver_announce, (void) );
|
||||
_PROTOTYPE( int netdriver_receive, (endpoint_t src, message *m_ptr,
|
||||
int *status_ptr) );
|
||||
void netdriver_announce(void);
|
||||
int netdriver_receive(endpoint_t src, message *m_ptr, int *status_ptr);
|
||||
|
||||
#endif /* _MINIX_NETDRIVER_H */
|
||||
|
||||
@@ -25,6 +25,6 @@ struct optset {
|
||||
int os_val;
|
||||
};
|
||||
|
||||
_PROTOTYPE( void optset_parse, (struct optset *table, char *string) );
|
||||
void optset_parse(struct optset *table, char *string);
|
||||
|
||||
#endif /* _MINIX_OPTSET_H */
|
||||
|
||||
@@ -70,12 +70,12 @@ struct sprof_proc {
|
||||
#define CPROF_ACCOUNCE_KERNEL 10000 /* kernel announces not directly */
|
||||
|
||||
/* Prototype for function called by procentry to get size of table. */
|
||||
_PROTOTYPE(int profile_get_tbl_size, (void) );
|
||||
int profile_get_tbl_size(void);
|
||||
/* Prototype for function called by procentry to get announce number. */
|
||||
_PROTOTYPE(int profile_get_announce, (void) );
|
||||
int profile_get_announce(void);
|
||||
/* Prototype for function called by procentry to announce control struct
|
||||
* and table locations to the kernel. */
|
||||
_PROTOTYPE(void profile_register, (void *ctl_ptr, void *tbl_ptr) );
|
||||
void profile_register(void *ctl_ptr, void *tbl_ptr);
|
||||
|
||||
/* Info struct to be copied from kernel to user program. */
|
||||
struct cprof_info_s {
|
||||
@@ -99,11 +99,10 @@ struct cprof_tbl_s {
|
||||
u64_t cycles; /* execution time of path, in cycles */
|
||||
} cprof_tbl_inst;
|
||||
|
||||
_PROTOTYPE( int sprofile, (int action, int size, int freq, int type,
|
||||
void *ctl_ptr, void *mem_ptr) );
|
||||
int sprofile(int action, int size, int freq, int type, void *ctl_ptr,
|
||||
void *mem_ptr);
|
||||
|
||||
_PROTOTYPE( int cprofile, (int action, int size, void *ctl_ptr,
|
||||
void *mem_ptr) );
|
||||
int cprofile(int action, int size, void *ctl_ptr, void *mem_ptr);
|
||||
|
||||
#endif /* PROFILE_H */
|
||||
|
||||
|
||||
@@ -118,6 +118,6 @@ struct rprocpub {
|
||||
int devman_id;
|
||||
};
|
||||
|
||||
_PROTOTYPE( int minix_rs_lookup, (const char *name, endpoint_t *value));
|
||||
int minix_rs_lookup(const char *name, endpoint_t *value);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -65,21 +65,22 @@ struct vscp_vec {
|
||||
#define CPF_VALID 0x001000 /* Grant slot contains valid grant. */
|
||||
|
||||
/* Prototypes for functions in libsys. */
|
||||
_PROTOTYPE( cp_grant_id_t cpf_grant_direct, (endpoint_t, vir_bytes, size_t, int));
|
||||
_PROTOTYPE( cp_grant_id_t cpf_grant_indirect, (endpoint_t, endpoint_t, cp_grant_id_t));
|
||||
_PROTOTYPE( cp_grant_id_t cpf_grant_magic, (endpoint_t, endpoint_t, vir_bytes, size_t, int));
|
||||
_PROTOTYPE( int cpf_revoke, (cp_grant_id_t grant_id));
|
||||
_PROTOTYPE( int cpf_lookup, (cp_grant_id_t g, endpoint_t *ep, endpoint_t *ep2));
|
||||
cp_grant_id_t cpf_grant_direct(endpoint_t, vir_bytes, size_t, int);
|
||||
cp_grant_id_t cpf_grant_indirect(endpoint_t, endpoint_t, cp_grant_id_t);
|
||||
cp_grant_id_t cpf_grant_magic(endpoint_t, endpoint_t, vir_bytes, size_t,
|
||||
int);
|
||||
int cpf_revoke(cp_grant_id_t grant_id);
|
||||
int cpf_lookup(cp_grant_id_t g, endpoint_t *ep, endpoint_t *ep2);
|
||||
|
||||
_PROTOTYPE( int cpf_getgrants, (cp_grant_id_t *grant_ids, int n));
|
||||
_PROTOTYPE( int cpf_setgrant_direct, (cp_grant_id_t g, endpoint_t who,
|
||||
vir_bytes addr, size_t size, int access));
|
||||
_PROTOTYPE( int cpf_setgrant_indirect, (cp_grant_id_t g, endpoint_t who_to,
|
||||
endpoint_t who_from, cp_grant_id_t his_g));
|
||||
_PROTOTYPE( int cpf_setgrant_magic, (cp_grant_id_t g, endpoint_t who_to,
|
||||
endpoint_t who_from, vir_bytes addr, size_t bytes, int access));
|
||||
_PROTOTYPE( int cpf_setgrant_disable, (cp_grant_id_t grant_id));
|
||||
_PROTOTYPE( void cpf_reload, (void));
|
||||
int cpf_getgrants(cp_grant_id_t *grant_ids, int n);
|
||||
int cpf_setgrant_direct(cp_grant_id_t g, endpoint_t who, vir_bytes addr,
|
||||
size_t size, int access);
|
||||
int cpf_setgrant_indirect(cp_grant_id_t g, endpoint_t who_to, endpoint_t
|
||||
who_from, cp_grant_id_t his_g);
|
||||
int cpf_setgrant_magic(cp_grant_id_t g, endpoint_t who_to, endpoint_t
|
||||
who_from, vir_bytes addr, size_t bytes, int access);
|
||||
int cpf_setgrant_disable(cp_grant_id_t grant_id);
|
||||
void cpf_reload(void);
|
||||
|
||||
/* Set a process' grant table location and size (in-kernel only). */
|
||||
#define _K_SET_GRANT_TABLE(rp, ptr, entries) \
|
||||
|
||||
@@ -3,12 +3,11 @@
|
||||
|
||||
#include <minix/ipc.h>
|
||||
|
||||
_PROTOTYPE(int sched_stop, (endpoint_t scheduler_e, endpoint_t schedulee_e));
|
||||
_PROTOTYPE(int sched_start, (endpoint_t scheduler_e, endpoint_t schedulee_e,
|
||||
endpoint_t parent_e, int maxprio, int quantum, int cpu,
|
||||
endpoint_t *newscheduler_e));
|
||||
_PROTOTYPE(int sched_inherit, (endpoint_t scheduler_e,
|
||||
endpoint_t schedulee_e, endpoint_t parent_e, unsigned maxprio,
|
||||
endpoint_t *newscheduler_e));
|
||||
int sched_stop(endpoint_t scheduler_e, endpoint_t schedulee_e);
|
||||
int sched_start(endpoint_t scheduler_e, endpoint_t schedulee_e,
|
||||
endpoint_t parent_e, int maxprio, int quantum, int cpu, endpoint_t
|
||||
*newscheduler_e);
|
||||
int sched_inherit(endpoint_t scheduler_e, endpoint_t schedulee_e,
|
||||
endpoint_t parent_e, unsigned maxprio, endpoint_t *newscheduler_e);
|
||||
|
||||
#endif /* _MINIX_SCHED_H */
|
||||
|
||||
@@ -6,10 +6,9 @@
|
||||
#include <minix/ipc.h>
|
||||
|
||||
/* SEF entry points for system processes. */
|
||||
_PROTOTYPE( void sef_startup, (void) );
|
||||
_PROTOTYPE( int sef_receive_status, (endpoint_t src, message *m_ptr,
|
||||
int *status_ptr) );
|
||||
_PROTOTYPE( void sef_exit, (int status) );
|
||||
void sef_startup(void);
|
||||
int sef_receive_status(endpoint_t src, message *m_ptr, int *status_ptr);
|
||||
void sef_exit(int status);
|
||||
#define sef_receive(src, m_ptr) sef_receive_status(src, m_ptr, NULL)
|
||||
|
||||
/* SEF Debug. */
|
||||
@@ -38,19 +37,19 @@ typedef int(*sef_cb_init_t)(int type, sef_init_info_t *info);
|
||||
typedef int(*sef_cb_init_response_t)(message *m_ptr);
|
||||
|
||||
/* Callback registration helpers. */
|
||||
_PROTOTYPE( void sef_setcb_init_fresh, (sef_cb_init_t cb));
|
||||
_PROTOTYPE( void sef_setcb_init_lu, (sef_cb_init_t cb));
|
||||
_PROTOTYPE( void sef_setcb_init_restart, (sef_cb_init_t cb));
|
||||
_PROTOTYPE( void sef_setcb_init_response, (sef_cb_init_response_t cb) );
|
||||
void sef_setcb_init_fresh(sef_cb_init_t cb);
|
||||
void sef_setcb_init_lu(sef_cb_init_t cb);
|
||||
void sef_setcb_init_restart(sef_cb_init_t cb);
|
||||
void sef_setcb_init_response(sef_cb_init_response_t cb);
|
||||
|
||||
/* Predefined callback implementations. */
|
||||
_PROTOTYPE( int sef_cb_init_null, (int type, sef_init_info_t *info) );
|
||||
_PROTOTYPE( int sef_cb_init_response_null, (message *m_ptr) );
|
||||
int sef_cb_init_null(int type, sef_init_info_t *info);
|
||||
int sef_cb_init_response_null(message *m_ptr);
|
||||
|
||||
_PROTOTYPE( int sef_cb_init_fail, (int type, sef_init_info_t *info) );
|
||||
_PROTOTYPE( int sef_cb_init_reset, (int type, sef_init_info_t *info) );
|
||||
_PROTOTYPE( int sef_cb_init_crash, (int type, sef_init_info_t *info) );
|
||||
_PROTOTYPE( int sef_cb_init_response_rs_reply, (message *m_ptr) );
|
||||
int sef_cb_init_fail(int type, sef_init_info_t *info);
|
||||
int sef_cb_init_reset(int type, sef_init_info_t *info);
|
||||
int sef_cb_init_crash(int type, sef_init_info_t *info);
|
||||
int sef_cb_init_response_rs_reply(message *m_ptr);
|
||||
|
||||
/* Macros for predefined callback implementations. */
|
||||
#define SEF_CB_INIT_FRESH_NULL sef_cb_init_null
|
||||
@@ -91,12 +90,12 @@ _PROTOTYPE( int sef_cb_init_response_rs_reply, (message *m_ptr) );
|
||||
typedef void(*sef_cb_ping_reply_t)(endpoint_t source);
|
||||
|
||||
/* Callback registration helpers. */
|
||||
_PROTOTYPE( void sef_setcb_ping_reply, (sef_cb_ping_reply_t cb));
|
||||
void sef_setcb_ping_reply(sef_cb_ping_reply_t cb);
|
||||
|
||||
/* Predefined callback implementations. */
|
||||
_PROTOTYPE( void sef_cb_ping_reply_null, (endpoint_t source) );
|
||||
void sef_cb_ping_reply_null(endpoint_t source);
|
||||
|
||||
_PROTOTYPE( void sef_cb_ping_reply_pong, (endpoint_t source) );
|
||||
void sef_cb_ping_reply_pong(endpoint_t source);
|
||||
|
||||
/* Macros for predefined callback implementations. */
|
||||
#define SEF_CB_PING_REPLY_NULL sef_cb_ping_reply_null
|
||||
@@ -131,27 +130,27 @@ typedef int(*sef_cb_lu_state_save_t)(int);
|
||||
typedef int(*sef_cb_lu_response_t)(message *m_ptr);
|
||||
|
||||
/* Callback registration helpers. */
|
||||
_PROTOTYPE( void sef_setcb_lu_prepare, (sef_cb_lu_prepare_t cb) );
|
||||
_PROTOTYPE( void sef_setcb_lu_state_isvalid, (sef_cb_lu_state_isvalid_t cb) );
|
||||
_PROTOTYPE( void sef_setcb_lu_state_changed, (sef_cb_lu_state_changed_t cb) );
|
||||
_PROTOTYPE( void sef_setcb_lu_state_dump, (sef_cb_lu_state_dump_t cb) );
|
||||
_PROTOTYPE( void sef_setcb_lu_state_save, (sef_cb_lu_state_save_t cb) );
|
||||
_PROTOTYPE( void sef_setcb_lu_response, (sef_cb_lu_response_t cb) );
|
||||
void sef_setcb_lu_prepare(sef_cb_lu_prepare_t cb);
|
||||
void sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_t cb);
|
||||
void sef_setcb_lu_state_changed(sef_cb_lu_state_changed_t cb);
|
||||
void sef_setcb_lu_state_dump(sef_cb_lu_state_dump_t cb);
|
||||
void sef_setcb_lu_state_save(sef_cb_lu_state_save_t cb);
|
||||
void sef_setcb_lu_response(sef_cb_lu_response_t cb);
|
||||
|
||||
/* Predefined callback implementations. */
|
||||
_PROTOTYPE( int sef_cb_lu_prepare_null, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_state_isvalid_null, (int state) );
|
||||
_PROTOTYPE( void sef_cb_lu_state_changed_null, (int old_state, int state) );
|
||||
_PROTOTYPE( void sef_cb_lu_state_dump_null, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_state_save_null, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_response_null, (message *m_ptr) );
|
||||
int sef_cb_lu_prepare_null(int state);
|
||||
int sef_cb_lu_state_isvalid_null(int state);
|
||||
void sef_cb_lu_state_changed_null(int old_state, int state);
|
||||
void sef_cb_lu_state_dump_null(int state);
|
||||
int sef_cb_lu_state_save_null(int state);
|
||||
int sef_cb_lu_response_null(message *m_ptr);
|
||||
|
||||
_PROTOTYPE( int sef_cb_lu_prepare_always_ready, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_prepare_never_ready, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_prepare_crash, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_state_isvalid_standard, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_state_isvalid_workfree, (int state) );
|
||||
_PROTOTYPE( int sef_cb_lu_response_rs_reply, (message *m_ptr) );
|
||||
int sef_cb_lu_prepare_always_ready(int state);
|
||||
int sef_cb_lu_prepare_never_ready(int state);
|
||||
int sef_cb_lu_prepare_crash(int state);
|
||||
int sef_cb_lu_state_isvalid_standard(int state);
|
||||
int sef_cb_lu_state_isvalid_workfree(int state);
|
||||
int sef_cb_lu_response_rs_reply(message *m_ptr);
|
||||
|
||||
/* Macros for predefined callback implementations. */
|
||||
#define SEF_CB_LU_PREPARE_NULL sef_cb_lu_prepare_null
|
||||
@@ -203,16 +202,16 @@ typedef int(*sef_cb_signal_manager_t)(endpoint_t target, int signo);
|
||||
typedef int(*sef_cb_gcov_t)(message *msg);
|
||||
|
||||
/* Callback registration helpers. */
|
||||
_PROTOTYPE( void sef_setcb_signal_handler, (sef_cb_signal_handler_t cb));
|
||||
_PROTOTYPE( void sef_setcb_signal_manager, (sef_cb_signal_manager_t cb));
|
||||
_PROTOTYPE( void sef_setcb_gcov, (sef_cb_gcov_t cb));
|
||||
void sef_setcb_signal_handler(sef_cb_signal_handler_t cb);
|
||||
void sef_setcb_signal_manager(sef_cb_signal_manager_t cb);
|
||||
void sef_setcb_gcov(sef_cb_gcov_t cb);
|
||||
|
||||
/* Predefined callback implementations. */
|
||||
_PROTOTYPE( void sef_cb_signal_handler_null, (int signo) );
|
||||
_PROTOTYPE( int sef_cb_signal_manager_null, (endpoint_t target, int signo) );
|
||||
void sef_cb_signal_handler_null(int signo);
|
||||
int sef_cb_signal_manager_null(endpoint_t target, int signo);
|
||||
|
||||
_PROTOTYPE( void sef_cb_signal_handler_term, (int signo) );
|
||||
_PROTOTYPE( void sef_cb_signal_handler_posix_default, (int signo) );
|
||||
void sef_cb_signal_handler_term(int signo);
|
||||
void sef_cb_signal_handler_posix_default(int signo);
|
||||
|
||||
/* Macros for predefined callback implementations. */
|
||||
#define SEF_CB_SIGNAL_HANDLER_NULL sef_cb_signal_handler_null
|
||||
|
||||
@@ -12,8 +12,8 @@ typedef struct {
|
||||
} spin_t;
|
||||
|
||||
/* Functions. */
|
||||
_PROTOTYPE( void spin_init, (spin_t *s, u32_t usecs) );
|
||||
_PROTOTYPE( int spin_check, (spin_t *s) );
|
||||
void spin_init(spin_t *s, u32_t usecs);
|
||||
int spin_check(spin_t *s);
|
||||
|
||||
/* Macros. */
|
||||
|
||||
|
||||
@@ -5,8 +5,7 @@
|
||||
#include <minix/endpoint.h>
|
||||
#include <minix/type.h>
|
||||
|
||||
_PROTOTYPE( int getsysinfo, (endpoint_t who, int what, void *where,
|
||||
size_t size) );
|
||||
int getsysinfo(endpoint_t who, int what, void *where, size_t size);
|
||||
|
||||
/* What system info to retrieve with sysgetinfo(). */
|
||||
#define SI_PROC_TAB 2 /* copy of entire process table */
|
||||
|
||||
@@ -30,59 +30,57 @@ struct rs_pci;
|
||||
/*==========================================================================*
|
||||
* Minix system library. *
|
||||
*==========================================================================*/
|
||||
_PROTOTYPE( int _taskcall, (endpoint_t who, int syscallnr, message *msgptr));
|
||||
_PROTOTYPE( int _kernel_call, (int syscallnr, message *msgptr));
|
||||
int _taskcall(endpoint_t who, int syscallnr, message *msgptr);
|
||||
int _kernel_call(int syscallnr, message *msgptr);
|
||||
|
||||
_PROTOTYPE( int sys_abort, (int how, ...));
|
||||
_PROTOTYPE( int sys_enable_iop, (endpoint_t proc_ep));
|
||||
_PROTOTYPE( int sys_exec, (endpoint_t proc_ep, char *ptr,
|
||||
char *aout, vir_bytes initpc));
|
||||
_PROTOTYPE( int sys_fork, (endpoint_t parent, endpoint_t child, endpoint_t *,
|
||||
struct mem_map *ptr, u32_t vm, vir_bytes *));
|
||||
_PROTOTYPE( int sys_newmap, (endpoint_t proc_ep, struct mem_map *ptr));
|
||||
_PROTOTYPE( int sys_clear, (endpoint_t proc_ep));
|
||||
_PROTOTYPE( int sys_exit, (void));
|
||||
_PROTOTYPE( int sys_trace, (int req, endpoint_t proc_ep, long addr, long *data_p));
|
||||
int sys_abort(int how, ...);
|
||||
int sys_enable_iop(endpoint_t proc_ep);
|
||||
int sys_exec(endpoint_t proc_ep, char *ptr, char *aout, vir_bytes
|
||||
initpc);
|
||||
int sys_fork(endpoint_t parent, endpoint_t child, endpoint_t *, struct
|
||||
mem_map *ptr, u32_t vm, vir_bytes *);
|
||||
int sys_newmap(endpoint_t proc_ep, struct mem_map *ptr);
|
||||
int sys_clear(endpoint_t proc_ep);
|
||||
int sys_exit(void);
|
||||
int sys_trace(int req, endpoint_t proc_ep, long addr, long *data_p);
|
||||
|
||||
_PROTOTYPE( int sys_schedule, (endpoint_t proc_ep, int priority,
|
||||
int quantum, int cpu));
|
||||
_PROTOTYPE( int sys_schedctl, (unsigned flags, endpoint_t proc_ep,
|
||||
int priority, int quantum, int cpu));
|
||||
int sys_schedule(endpoint_t proc_ep, int priority, int quantum, int
|
||||
cpu);
|
||||
int sys_schedctl(unsigned flags, endpoint_t proc_ep, int priority, int
|
||||
quantum, int cpu);
|
||||
|
||||
/* Shorthands for sys_runctl() system call. */
|
||||
#define sys_stop(proc_ep) sys_runctl(proc_ep, RC_STOP, 0)
|
||||
#define sys_delay_stop(proc_ep) sys_runctl(proc_ep, RC_STOP, RC_DELAY)
|
||||
#define sys_resume(proc_ep) sys_runctl(proc_ep, RC_RESUME, 0)
|
||||
_PROTOTYPE( int sys_runctl, (endpoint_t proc_ep, int action, int flags));
|
||||
int sys_runctl(endpoint_t proc_ep, int action, int flags);
|
||||
|
||||
_PROTOTYPE( int sys_update, (endpoint_t src_ep, endpoint_t dst_ep));
|
||||
_PROTOTYPE( int sys_statectl, (int request));
|
||||
_PROTOTYPE( int sys_privctl, (endpoint_t proc_ep, int req, void *p));
|
||||
_PROTOTYPE( int sys_privquery_mem, (endpoint_t proc_ep,
|
||||
phys_bytes physstart, phys_bytes physlen));
|
||||
_PROTOTYPE( int sys_setgrant, (cp_grant_t *grants, int ngrants));
|
||||
int sys_update(endpoint_t src_ep, endpoint_t dst_ep);
|
||||
int sys_statectl(int request);
|
||||
int sys_privctl(endpoint_t proc_ep, int req, void *p);
|
||||
int sys_privquery_mem(endpoint_t proc_ep, phys_bytes physstart,
|
||||
phys_bytes physlen);
|
||||
int sys_setgrant(cp_grant_t *grants, int ngrants);
|
||||
|
||||
_PROTOTYPE( int sys_int86, (struct reg86u *reg86p));
|
||||
_PROTOTYPE( int sys_vm_setbuf, (phys_bytes base, phys_bytes size,
|
||||
phys_bytes high));
|
||||
_PROTOTYPE( int sys_vm_map, (endpoint_t proc_ep, int do_map,
|
||||
phys_bytes base, phys_bytes size, phys_bytes offset));
|
||||
_PROTOTYPE( int sys_vmctl, (endpoint_t who, int param, u32_t value));
|
||||
_PROTOTYPE( int sys_vmctl_get_cr3_i386, (endpoint_t who, u32_t *cr3) );
|
||||
_PROTOTYPE( int sys_vmctl_get_memreq, (endpoint_t *who, vir_bytes *mem,
|
||||
vir_bytes *len, int *wrflag, endpoint_t *who_s, vir_bytes *mem_s,
|
||||
endpoint_t *) );
|
||||
_PROTOTYPE( int sys_vmctl_enable_paging, (void * data));
|
||||
int sys_int86(struct reg86u *reg86p);
|
||||
int sys_vm_setbuf(phys_bytes base, phys_bytes size, phys_bytes high);
|
||||
int sys_vm_map(endpoint_t proc_ep, int do_map, phys_bytes base,
|
||||
phys_bytes size, phys_bytes offset);
|
||||
int sys_vmctl(endpoint_t who, int param, u32_t value);
|
||||
int sys_vmctl_get_cr3_i386(endpoint_t who, u32_t *cr3);
|
||||
int sys_vmctl_get_memreq(endpoint_t *who, vir_bytes *mem, vir_bytes
|
||||
*len, int *wrflag, endpoint_t *who_s, vir_bytes *mem_s, endpoint_t *);
|
||||
int sys_vmctl_enable_paging(void * data);
|
||||
|
||||
_PROTOTYPE( int sys_readbios, (phys_bytes address, void *buf, size_t size));
|
||||
_PROTOTYPE( int sys_stime, (time_t boottime));
|
||||
_PROTOTYPE( int sys_sysctl, (int ctl, char *arg1, int arg2));
|
||||
_PROTOTYPE( int sys_sysctl_stacktrace, (endpoint_t who));
|
||||
_PROTOTYPE( int sys_vmctl_get_mapping, (int index, phys_bytes *addr,
|
||||
phys_bytes *len, int *flags));
|
||||
_PROTOTYPE( int sys_vmctl_reply_mapping, (int index, vir_bytes addr));
|
||||
_PROTOTYPE( int sys_vmctl_set_addrspace, (endpoint_t who,
|
||||
phys_bytes ptroot, void *ptroot_v));
|
||||
int sys_readbios(phys_bytes address, void *buf, size_t size);
|
||||
int sys_stime(time_t boottime);
|
||||
int sys_sysctl(int ctl, char *arg1, int arg2);
|
||||
int sys_sysctl_stacktrace(endpoint_t who);
|
||||
int sys_vmctl_get_mapping(int index, phys_bytes *addr, phys_bytes *len,
|
||||
int *flags);
|
||||
int sys_vmctl_reply_mapping(int index, vir_bytes addr);
|
||||
int sys_vmctl_set_addrspace(endpoint_t who, phys_bytes ptroot, void
|
||||
*ptroot_v);
|
||||
|
||||
|
||||
/* Shorthands for sys_sdevio() system call. */
|
||||
@@ -102,10 +100,10 @@ _PROTOTYPE( int sys_vmctl_set_addrspace, (endpoint_t who,
|
||||
sys_sdevio(DIO_SAFE_INPUT_WORD, port, ept, (void*)grant, count, offset)
|
||||
#define sys_safe_outsw(port, ept, grant, offset, count) \
|
||||
sys_sdevio(DIO_SAFE_OUTPUT_WORD, port, ept, (void*)grant, count, offset)
|
||||
_PROTOTYPE( int sys_sdevio, (int req, long port, endpoint_t proc_ep,
|
||||
void *buffer, int count, vir_bytes offset));
|
||||
_PROTOTYPE(void *alloc_contig, (size_t len, int flags, phys_bytes *phys));
|
||||
_PROTOTYPE(int free_contig, (void *addr, size_t len));
|
||||
int sys_sdevio(int req, long port, endpoint_t proc_ep, void *buffer, int
|
||||
count, vir_bytes offset);
|
||||
void *alloc_contig(size_t len, int flags, phys_bytes *phys);
|
||||
int free_contig(void *addr, size_t len);
|
||||
|
||||
#define AC_ALIGN4K 0x01
|
||||
#define AC_LOWER16M 0x02
|
||||
@@ -115,11 +113,11 @@ _PROTOTYPE(int free_contig, (void *addr, size_t len));
|
||||
/* Clock functionality: get system times, (un)schedule an alarm call, or
|
||||
* retrieve/set a process-virtual timer.
|
||||
*/
|
||||
_PROTOTYPE( int sys_times, (endpoint_t proc_ep, clock_t *user_time,
|
||||
clock_t *sys_time, clock_t *uptime, time_t *boottime));
|
||||
_PROTOTYPE(int sys_setalarm, (clock_t exp_time, int abs_time));
|
||||
_PROTOTYPE( int sys_vtimer, (endpoint_t proc_nr, int which, clock_t *newval,
|
||||
clock_t *oldval));
|
||||
int sys_times(endpoint_t proc_ep, clock_t *user_time, clock_t *sys_time,
|
||||
clock_t *uptime, time_t *boottime);
|
||||
int sys_setalarm(clock_t exp_time, int abs_time);
|
||||
int sys_vtimer(endpoint_t proc_nr, int which, clock_t *newval, clock_t
|
||||
*oldval);
|
||||
|
||||
/* Shorthands for sys_irqctl() system call. */
|
||||
#define sys_irqdisable(hook_id) \
|
||||
@@ -130,8 +128,7 @@ _PROTOTYPE( int sys_vtimer, (endpoint_t proc_nr, int which, clock_t *newval,
|
||||
sys_irqctl(IRQ_SETPOLICY, irq_vec, policy, hook_id)
|
||||
#define sys_irqrmpolicy(hook_id) \
|
||||
sys_irqctl(IRQ_RMPOLICY, 0, 0, hook_id)
|
||||
_PROTOTYPE ( int sys_irqctl, (int request, int irq_vec, int policy,
|
||||
int *irq_hook_id) );
|
||||
int sys_irqctl(int request, int irq_vec, int policy, int *irq_hook_id);
|
||||
|
||||
/* Shorthands for sys_vircopy() and sys_physcopy() system calls. */
|
||||
#define sys_biosin(bios_vir, dst_vir, bytes) \
|
||||
@@ -144,42 +141,42 @@ _PROTOTYPE ( int sys_irqctl, (int request, int irq_vec, int policy,
|
||||
sys_vircopy(src_proc, T, src_vir, dst_proc, T, dst_vir, bytes)
|
||||
#define sys_stackcopy(src_proc, src_vir, dst_proc, dst_vir, bytes) \
|
||||
sys_vircopy(src_proc, S, src_vir, dst_proc, S, dst_vir, bytes)
|
||||
_PROTOTYPE(int sys_vircopy, (endpoint_t src_proc, int src_s, vir_bytes src_v,
|
||||
endpoint_t dst_proc, int dst_seg, vir_bytes dst_vir, phys_bytes bytes));
|
||||
int sys_vircopy(endpoint_t src_proc, int src_s, vir_bytes src_v,
|
||||
endpoint_t dst_proc, int dst_seg, vir_bytes dst_vir, phys_bytes bytes);
|
||||
|
||||
#define sys_abscopy(src_phys, dst_phys, bytes) \
|
||||
sys_physcopy(NONE, PHYS_SEG, src_phys, NONE, PHYS_SEG, dst_phys, bytes)
|
||||
_PROTOTYPE(int sys_physcopy, (endpoint_t src_proc, int src_seg, vir_bytes src_vir,
|
||||
endpoint_t dst_proc, int dst_seg, vir_bytes dst_vir, phys_bytes bytes));
|
||||
int sys_physcopy(endpoint_t src_proc, int src_seg, vir_bytes src_vir,
|
||||
endpoint_t dst_proc, int dst_seg, vir_bytes dst_vir, phys_bytes bytes);
|
||||
|
||||
|
||||
/* Grant-based copy functions. */
|
||||
_PROTOTYPE(int sys_safecopyfrom, (endpoint_t source, cp_grant_id_t grant,
|
||||
vir_bytes grant_offset, vir_bytes my_address, size_t bytes, int my_seg));
|
||||
_PROTOTYPE(int sys_safecopyto, (endpoint_t dest, cp_grant_id_t grant,
|
||||
vir_bytes grant_offset, vir_bytes my_address, size_t bytes, int my_seg));
|
||||
_PROTOTYPE(int sys_vsafecopy, (struct vscp_vec *copyvec, int elements));
|
||||
int sys_safecopyfrom(endpoint_t source, cp_grant_id_t grant, vir_bytes
|
||||
grant_offset, vir_bytes my_address, size_t bytes, int my_seg);
|
||||
int sys_safecopyto(endpoint_t dest, cp_grant_id_t grant, vir_bytes
|
||||
grant_offset, vir_bytes my_address, size_t bytes, int my_seg);
|
||||
int sys_vsafecopy(struct vscp_vec *copyvec, int elements);
|
||||
|
||||
_PROTOTYPE(int sys_memset, (unsigned long pattern,
|
||||
phys_bytes base, phys_bytes bytes));
|
||||
int sys_memset(unsigned long pattern, phys_bytes base, phys_bytes
|
||||
bytes);
|
||||
|
||||
/* Grant-based map functions. */
|
||||
_PROTOTYPE(int sys_safemap, (endpoint_t grantor, cp_grant_id_t grant,
|
||||
vir_bytes grant_offset, vir_bytes my_address, size_t bytes, int my_seg,
|
||||
int writable));
|
||||
_PROTOTYPE(int sys_saferevmap_gid, (cp_grant_id_t grant));
|
||||
_PROTOTYPE(int sys_saferevmap_addr, (vir_bytes addr));
|
||||
_PROTOTYPE(int sys_safeunmap, (int my_seg, vir_bytes my_address));
|
||||
int sys_safemap(endpoint_t grantor, cp_grant_id_t grant, vir_bytes
|
||||
grant_offset, vir_bytes my_address, size_t bytes, int my_seg, int
|
||||
writable);
|
||||
int sys_saferevmap_gid(cp_grant_id_t grant);
|
||||
int sys_saferevmap_addr(vir_bytes addr);
|
||||
int sys_safeunmap(int my_seg, vir_bytes my_address);
|
||||
|
||||
_PROTOTYPE(int sys_umap, (endpoint_t proc_ep, int seg, vir_bytes vir_addr,
|
||||
vir_bytes bytes, phys_bytes *phys_addr));
|
||||
_PROTOTYPE(int sys_umap_data_fb, (endpoint_t proc_ep, vir_bytes vir_addr,
|
||||
vir_bytes bytes, phys_bytes *phys_addr));
|
||||
_PROTOTYPE(int sys_umap_remote, (endpoint_t proc_ep, endpoint_t grantee,
|
||||
int seg, vir_bytes vir_addr, vir_bytes bytes, phys_bytes *phys_addr));
|
||||
_PROTOTYPE(int sys_vumap, (endpoint_t endpt, struct vumap_vir *vvec,
|
||||
int sys_vumap(endpoint_t endpt, struct vumap_vir *vvec,
|
||||
int vcount, size_t offset, int access, struct vumap_phys *pvec,
|
||||
int *pcount));
|
||||
int *pcount);
|
||||
int sys_umap(endpoint_t proc_ep, int seg, vir_bytes vir_addr, vir_bytes
|
||||
bytes, phys_bytes *phys_addr);
|
||||
int sys_umap_data_fb(endpoint_t proc_ep, vir_bytes vir_addr, vir_bytes
|
||||
bytes, phys_bytes *phys_addr);
|
||||
int sys_umap_remote(endpoint_t proc_ep, endpoint_t grantee, int seg,
|
||||
vir_bytes vir_addr, vir_bytes bytes, phys_bytes *phys_addr);
|
||||
|
||||
/* Shorthands for sys_getinfo() system call. */
|
||||
#define sys_getkmessages(dst) sys_getinfo(GET_KMESSAGES, dst, 0,0,0)
|
||||
@@ -200,77 +197,76 @@ _PROTOTYPE(int sys_vumap, (endpoint_t endpt, struct vumap_vir *vvec,
|
||||
#define sys_getpriv(dst, nr) sys_getinfo(GET_PRIV, dst, 0,0, nr)
|
||||
#define sys_getidletsc(dst) sys_getinfo(GET_IDLETSC, dst, 0,0,0)
|
||||
#define sys_getregs(dst,nr) sys_getinfo(GET_REGS, dst, 0,0, nr)
|
||||
_PROTOTYPE(int sys_getinfo, (int request, void *val_ptr, int val_len,
|
||||
void *val_ptr2, int val_len2) );
|
||||
_PROTOTYPE(int sys_whoami, (endpoint_t *ep, char *name, int namelen,
|
||||
int *priv_flags));
|
||||
int sys_getinfo(int request, void *val_ptr, int val_len, void *val_ptr2,
|
||||
int val_len2);
|
||||
int sys_whoami(endpoint_t *ep, char *name, int namelen, int
|
||||
*priv_flags);
|
||||
|
||||
/* Signal control. */
|
||||
_PROTOTYPE(int sys_kill, (endpoint_t proc_ep, int sig) );
|
||||
_PROTOTYPE(int sys_sigsend, (endpoint_t proc_ep, struct sigmsg *sig_ctxt) );
|
||||
_PROTOTYPE(int sys_sigreturn, (endpoint_t proc_ep, struct sigmsg *sig_ctxt) );
|
||||
_PROTOTYPE(int sys_getksig, (endpoint_t *proc_ep, sigset_t *k_sig_map) );
|
||||
_PROTOTYPE(int sys_endksig, (endpoint_t proc_ep) );
|
||||
int sys_kill(endpoint_t proc_ep, int sig);
|
||||
int sys_sigsend(endpoint_t proc_ep, struct sigmsg *sig_ctxt);
|
||||
int sys_sigreturn(endpoint_t proc_ep, struct sigmsg *sig_ctxt);
|
||||
int sys_getksig(endpoint_t *proc_ep, sigset_t *k_sig_map);
|
||||
int sys_endksig(endpoint_t proc_ep);
|
||||
|
||||
/* NOTE: two different approaches were used to distinguish the device I/O
|
||||
* types 'byte', 'word', 'long': the latter uses #define and results in a
|
||||
* smaller implementation, but looses the static type checking.
|
||||
*/
|
||||
_PROTOTYPE(int sys_voutb, (pvb_pair_t *pvb_pairs, int nr_ports) );
|
||||
_PROTOTYPE(int sys_voutw, (pvw_pair_t *pvw_pairs, int nr_ports) );
|
||||
_PROTOTYPE(int sys_voutl, (pvl_pair_t *pvl_pairs, int nr_ports) );
|
||||
_PROTOTYPE(int sys_vinb, (pvb_pair_t *pvb_pairs, int nr_ports) );
|
||||
_PROTOTYPE(int sys_vinw, (pvw_pair_t *pvw_pairs, int nr_ports) );
|
||||
_PROTOTYPE(int sys_vinl, (pvl_pair_t *pvl_pairs, int nr_ports) );
|
||||
int sys_voutb(pvb_pair_t *pvb_pairs, int nr_ports);
|
||||
int sys_voutw(pvw_pair_t *pvw_pairs, int nr_ports);
|
||||
int sys_voutl(pvl_pair_t *pvl_pairs, int nr_ports);
|
||||
int sys_vinb(pvb_pair_t *pvb_pairs, int nr_ports);
|
||||
int sys_vinw(pvw_pair_t *pvw_pairs, int nr_ports);
|
||||
int sys_vinl(pvl_pair_t *pvl_pairs, int nr_ports);
|
||||
|
||||
/* Shorthands for sys_out() system call. */
|
||||
#define sys_outb(p,v) sys_out((p), (u32_t) (v), _DIO_BYTE)
|
||||
#define sys_outw(p,v) sys_out((p), (u32_t) (v), _DIO_WORD)
|
||||
#define sys_outl(p,v) sys_out((p), (u32_t) (v), _DIO_LONG)
|
||||
_PROTOTYPE(int sys_out, (int port, u32_t value, int type) );
|
||||
int sys_out(int port, u32_t value, int type);
|
||||
|
||||
/* Shorthands for sys_in() system call. */
|
||||
#define sys_inb(p,v) sys_in((p), (v), _DIO_BYTE)
|
||||
#define sys_inw(p,v) sys_in((p), (v), _DIO_WORD)
|
||||
#define sys_inl(p,v) sys_in((p), (v), _DIO_LONG)
|
||||
_PROTOTYPE(int sys_in, (int port, u32_t *value, int type) );
|
||||
int sys_in(int port, u32_t *value, int type);
|
||||
|
||||
/* pci.c */
|
||||
_PROTOTYPE( void pci_init, (void) );
|
||||
_PROTOTYPE( int pci_first_dev, (int *devindp, u16_t *vidp, u16_t *didp) );
|
||||
_PROTOTYPE( int pci_next_dev, (int *devindp, u16_t *vidp, u16_t *didp) );
|
||||
_PROTOTYPE( int pci_find_dev, (u8_t bus, u8_t dev, u8_t func,
|
||||
int *devindp) );
|
||||
_PROTOTYPE( void pci_reserve, (int devind) );
|
||||
_PROTOTYPE( int pci_reserve_ok, (int devind) );
|
||||
_PROTOTYPE( void pci_ids, (int devind, u16_t *vidp, u16_t *didp) );
|
||||
_PROTOTYPE( void pci_rescan_bus, (u8_t busnr) );
|
||||
_PROTOTYPE( u8_t pci_attr_r8, (int devind, int port) );
|
||||
_PROTOTYPE( u16_t pci_attr_r16, (int devind, int port) );
|
||||
_PROTOTYPE( u32_t pci_attr_r32, (int devind, int port) );
|
||||
_PROTOTYPE( void pci_attr_w8, (int devind, int port, u8_t value) );
|
||||
_PROTOTYPE( void pci_attr_w16, (int devind, int port, u16_t value) );
|
||||
_PROTOTYPE( void pci_attr_w32, (int devind, int port, u32_t value) );
|
||||
_PROTOTYPE( char *pci_dev_name, (u16_t vid, u16_t did) );
|
||||
_PROTOTYPE( char *pci_slot_name, (int devind) );
|
||||
_PROTOTYPE( int pci_set_acl, (struct rs_pci *rs_pci) );
|
||||
_PROTOTYPE( int pci_del_acl, (endpoint_t proc_ep) );
|
||||
_PROTOTYPE( int pci_get_bar, (int devind, int port, u32_t *base,
|
||||
u32_t *size, int *ioflag) );
|
||||
void pci_init(void);
|
||||
int pci_first_dev(int *devindp, u16_t *vidp, u16_t *didp);
|
||||
int pci_next_dev(int *devindp, u16_t *vidp, u16_t *didp);
|
||||
int pci_find_dev(u8_t bus, u8_t dev, u8_t func, int *devindp);
|
||||
void pci_reserve(int devind);
|
||||
int pci_reserve_ok(int devind);
|
||||
void pci_ids(int devind, u16_t *vidp, u16_t *didp);
|
||||
void pci_rescan_bus(u8_t busnr);
|
||||
u8_t pci_attr_r8(int devind, int port);
|
||||
u16_t pci_attr_r16(int devind, int port);
|
||||
u32_t pci_attr_r32(int devind, int port);
|
||||
void pci_attr_w8(int devind, int port, u8_t value);
|
||||
void pci_attr_w16(int devind, int port, u16_t value);
|
||||
void pci_attr_w32(int devind, int port, u32_t value);
|
||||
char *pci_dev_name(u16_t vid, u16_t did);
|
||||
char *pci_slot_name(int devind);
|
||||
int pci_set_acl(struct rs_pci *rs_pci);
|
||||
int pci_del_acl(endpoint_t proc_ep);
|
||||
int pci_get_bar(int devind, int port, u32_t *base, u32_t *size, int
|
||||
*ioflag);
|
||||
|
||||
/* Profiling. */
|
||||
_PROTOTYPE( int sys_sprof, (int action, int size, int freq, int type,
|
||||
endpoint_t endpt, void *ctl_ptr, void *mem_ptr) );
|
||||
_PROTOTYPE( int sys_cprof, (int action, int size, endpoint_t endpt,
|
||||
void *ctl_ptr, void *mem_ptr) );
|
||||
_PROTOTYPE( int sys_profbuf, (void *ctl_ptr, void *mem_ptr) );
|
||||
int sys_sprof(int action, int size, int freq, int type, endpoint_t
|
||||
endpt, void *ctl_ptr, void *mem_ptr);
|
||||
int sys_cprof(int action, int size, endpoint_t endpt, void *ctl_ptr,
|
||||
void *mem_ptr);
|
||||
int sys_profbuf(void *ctl_ptr, void *mem_ptr);
|
||||
|
||||
/* machine context */
|
||||
_PROTOTYPE( int sys_getmcontext, (endpoint_t proc, mcontext_t *mcp) );
|
||||
_PROTOTYPE( int sys_setmcontext, (endpoint_t proc, mcontext_t *mcp) );
|
||||
int sys_getmcontext(endpoint_t proc, mcontext_t *mcp);
|
||||
int sys_setmcontext(endpoint_t proc, mcontext_t *mcp);
|
||||
|
||||
/* input */
|
||||
_PROTOTYPE( int tty_input_inject, (int type, int code, int val) );
|
||||
int tty_input_inject(int type, int code, int val);
|
||||
|
||||
#endif /* _SYSLIB_H */
|
||||
|
||||
|
||||
@@ -34,42 +34,42 @@
|
||||
extern int env_argc;
|
||||
extern char **env_argv;
|
||||
|
||||
_PROTOTYPE( void env_setargs, (int argc, char *argv[]) );
|
||||
_PROTOTYPE( int env_get_param, (char *key, char *value, int max_size) );
|
||||
_PROTOTYPE( int env_prefix, (char *env, char *prefix) );
|
||||
_PROTOTYPE( void env_panic, (char *key) );
|
||||
_PROTOTYPE( int env_parse, (char *env, char *fmt, int field, long *param,
|
||||
long min, long max) );
|
||||
void env_setargs(int argc, char *argv[]);
|
||||
int env_get_param(char *key, char *value, int max_size);
|
||||
int env_prefix(char *env, char *prefix);
|
||||
void env_panic(char *key);
|
||||
int env_parse(char *env, char *fmt, int field, long *param, long min,
|
||||
long max);
|
||||
|
||||
#define fkey_map(fkeys, sfkeys) fkey_ctl(FKEY_MAP, (fkeys), (sfkeys))
|
||||
#define fkey_unmap(fkeys, sfkeys) fkey_ctl(FKEY_UNMAP, (fkeys), (sfkeys))
|
||||
#define fkey_events(fkeys, sfkeys) fkey_ctl(FKEY_EVENTS, (fkeys), (sfkeys))
|
||||
_PROTOTYPE( int fkey_ctl, (int req, int *fkeys, int *sfkeys) );
|
||||
int fkey_ctl(int req, int *fkeys, int *sfkeys);
|
||||
|
||||
_PROTOTYPE( int printf, (const char *fmt, ...));
|
||||
_PROTOTYPE( void kputc, (int c));
|
||||
_PROTOTYPE( __dead void panic, (const char *fmt, ...));
|
||||
_PROTOTYPE( int getuptime, (clock_t *ticks));
|
||||
_PROTOTYPE( int getuptime2, (clock_t *ticks, time_t *boottime));
|
||||
_PROTOTYPE( int tickdelay, (clock_t ticks));
|
||||
_PROTOTYPE( int tsc_calibrate, (void));
|
||||
_PROTOTYPE( u32_t sys_hz, (void));
|
||||
_PROTOTYPE( double getidle, (void));
|
||||
_PROTOTYPE( void util_stacktrace, (void));
|
||||
_PROTOTYPE( void util_nstrcat, (char *str, unsigned long n) );
|
||||
_PROTOTYPE( void util_stacktrace_strcat, (char *));
|
||||
_PROTOTYPE( int micro_delay, (u32_t micros));
|
||||
_PROTOTYPE( u32_t tsc_64_to_micros, (u64_t tsc));
|
||||
_PROTOTYPE( u32_t tsc_to_micros, (u32_t low, u32_t high));
|
||||
_PROTOTYPE( u32_t tsc_get_khz, (void));
|
||||
_PROTOTYPE( u32_t micros_to_ticks, (u32_t micros));
|
||||
_PROTOTYPE( void ser_putc, (char c));
|
||||
_PROTOTYPE( void get_randomness, (struct k_randomness *, int));
|
||||
_PROTOTYPE( u32_t sqrt_approx, (u32_t));
|
||||
int printf(const char *fmt, ...);
|
||||
void kputc(int c);
|
||||
__dead void panic(const char *fmt, ...);
|
||||
int getuptime(clock_t *ticks);
|
||||
int getuptime2(clock_t *ticks, time_t *boottime);
|
||||
int tickdelay(clock_t ticks);
|
||||
int tsc_calibrate(void);
|
||||
u32_t sys_hz(void);
|
||||
double getidle(void);
|
||||
void util_stacktrace(void);
|
||||
void util_nstrcat(char *str, unsigned long n);
|
||||
void util_stacktrace_strcat(char *);
|
||||
int micro_delay(u32_t micros);
|
||||
u32_t tsc_64_to_micros(u64_t tsc);
|
||||
u32_t tsc_to_micros(u32_t low, u32_t high);
|
||||
u32_t tsc_get_khz(void);
|
||||
u32_t micros_to_ticks(u32_t micros);
|
||||
void ser_putc(char c);
|
||||
void get_randomness(struct k_randomness *, int);
|
||||
u32_t sqrt_approx(u32_t);
|
||||
|
||||
#define asynsend(ep, msg) asynsend3(ep, msg, 0)
|
||||
_PROTOTYPE( int asynsend3, (endpoint_t ep, message *msg, int flags));
|
||||
_PROTOTYPE( int asyn_geterror, (endpoint_t *dst, message *msg, int *err));
|
||||
int asynsend3(endpoint_t ep, message *msg, int flags);
|
||||
int asyn_geterror(endpoint_t *dst, message *msg, int *err);
|
||||
|
||||
#define ASSERT(c) if(!(c)) { panic("%s:%d: assert %s failed", __FILE__, __LINE__, #c); }
|
||||
|
||||
|
||||
@@ -7,10 +7,9 @@
|
||||
|
||||
#include <timers.h>
|
||||
|
||||
_PROTOTYPE( void init_timer, (timer_t *tp));
|
||||
_PROTOTYPE( void set_timer, (timer_t *tp, int ticks, tmr_func_t watchdog,
|
||||
int arg));
|
||||
_PROTOTYPE( void cancel_timer, (timer_t *tp));
|
||||
_PROTOTYPE( void expire_timers, (clock_t now));
|
||||
void init_timer(timer_t *tp);
|
||||
void set_timer(timer_t *tp, int ticks, tmr_func_t watchdog, int arg);
|
||||
void cancel_timer(timer_t *tp);
|
||||
void expire_timers(clock_t now);
|
||||
|
||||
#endif /* _MINIX_TIMERS_H */
|
||||
|
||||
@@ -6,32 +6,29 @@
|
||||
#include <minix/types.h>
|
||||
#include <minix/endpoint.h>
|
||||
|
||||
_PROTOTYPE( int vm_exit, (endpoint_t ep));
|
||||
_PROTOTYPE( int vm_fork, (endpoint_t ep, int slotno, endpoint_t *child_ep));
|
||||
_PROTOTYPE( int vm_brk, (endpoint_t ep, char *newaddr));
|
||||
_PROTOTYPE( int vm_exec_newmem, (endpoint_t ep, struct exec_newmem *args,
|
||||
int args_bytes, char **ret_stack_top, int *ret_flags));
|
||||
_PROTOTYPE( int vm_push_sig, (endpoint_t ep, vir_bytes *old_sp));
|
||||
_PROTOTYPE( int vm_willexit, (endpoint_t ep));
|
||||
_PROTOTYPE( int vm_adddma, (endpoint_t proc_e, phys_bytes start,
|
||||
phys_bytes size));
|
||||
_PROTOTYPE( int vm_deldma, (endpoint_t proc_e, phys_bytes start,
|
||||
phys_bytes size));
|
||||
_PROTOTYPE( int vm_getdma, (endpoint_t *procp, phys_bytes *basep,
|
||||
phys_bytes *sizep));
|
||||
_PROTOTYPE( void *vm_map_phys, (endpoint_t who, void *physaddr, size_t len));
|
||||
_PROTOTYPE( int vm_unmap_phys, (endpoint_t who, void *vaddr, size_t len));
|
||||
int vm_exit(endpoint_t ep);
|
||||
int vm_fork(endpoint_t ep, int slotno, endpoint_t *child_ep);
|
||||
int vm_brk(endpoint_t ep, char *newaddr);
|
||||
int vm_exec_newmem(endpoint_t ep, struct exec_newmem *args, int
|
||||
args_bytes, char **ret_stack_top, int *ret_flags);
|
||||
int vm_push_sig(endpoint_t ep, vir_bytes *old_sp);
|
||||
int vm_willexit(endpoint_t ep);
|
||||
int vm_adddma(endpoint_t proc_e, phys_bytes start, phys_bytes size);
|
||||
int vm_deldma(endpoint_t proc_e, phys_bytes start, phys_bytes size);
|
||||
int vm_getdma(endpoint_t *procp, phys_bytes *basep, phys_bytes *sizep);
|
||||
void *vm_map_phys(endpoint_t who, void *physaddr, size_t len);
|
||||
int vm_unmap_phys(endpoint_t who, void *vaddr, size_t len);
|
||||
|
||||
_PROTOTYPE( int vm_notify_sig, (endpoint_t ep, endpoint_t ipc_ep));
|
||||
_PROTOTYPE( int vm_set_priv, (int procnr, void *buf));
|
||||
_PROTOTYPE( int vm_update, (endpoint_t src_e, endpoint_t dst_e));
|
||||
_PROTOTYPE( int vm_memctl, (endpoint_t ep, int req));
|
||||
_PROTOTYPE( int vm_query_exit, (endpoint_t *endpt));
|
||||
_PROTOTYPE( int vm_watch_exit, (endpoint_t ep));
|
||||
_PROTOTYPE( int vm_forgetblock, (u64_t id));
|
||||
_PROTOTYPE( void vm_forgetblocks, (void));
|
||||
_PROTOTYPE( int vm_yield_block_get_block, (u64_t yieldid, u64_t getid,
|
||||
void *mem, vir_bytes len));
|
||||
int vm_notify_sig(endpoint_t ep, endpoint_t ipc_ep);
|
||||
int vm_set_priv(int procnr, void *buf);
|
||||
int vm_update(endpoint_t src_e, endpoint_t dst_e);
|
||||
int vm_memctl(endpoint_t ep, int req);
|
||||
int vm_query_exit(endpoint_t *endpt);
|
||||
int vm_watch_exit(endpoint_t ep);
|
||||
int vm_forgetblock(u64_t id);
|
||||
void vm_forgetblocks(void);
|
||||
int vm_yield_block_get_block(u64_t yieldid, u64_t getid, void *mem,
|
||||
vir_bytes len);
|
||||
|
||||
/* Invalid ID with special meaning for the vm_yield_block_get_block
|
||||
* interface.
|
||||
@@ -69,11 +66,10 @@ struct vm_region_info {
|
||||
|
||||
#define MAX_VRI_COUNT 64 /* max. number of regions provided at once */
|
||||
|
||||
_PROTOTYPE( int vm_info_stats, (struct vm_stats_info *vfi) );
|
||||
_PROTOTYPE( int vm_info_usage, (endpoint_t who,
|
||||
struct vm_usage_info *vui) );
|
||||
_PROTOTYPE( int vm_info_region, (endpoint_t who,
|
||||
struct vm_region_info *vri, int count, vir_bytes *next) );
|
||||
int vm_info_stats(struct vm_stats_info *vfi);
|
||||
int vm_info_usage(endpoint_t who, struct vm_usage_info *vui);
|
||||
int vm_info_region(endpoint_t who, struct vm_region_info *vri, int
|
||||
count, vir_bytes *next);
|
||||
|
||||
#endif /* _MINIX_VM_H */
|
||||
|
||||
|
||||
Reference in New Issue
Block a user