Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

retire _PROTOTYPE

Browse Source 
. only good for obsolete K&R support
	. also remove a stray ansi.h and the proto cmd
This commit is contained in:
Ben Gras
2012-03-24 16:16:34 +01:00
parent cf720a028a
commit 6a73e85ad1
475 changed files with 5256 additions and 6252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/ddekit/condvar.h
View File

@@ -10,23 +10,22 @@ struct ddekit_condvar;
typedef struct ddekit_condvar ddekit_condvar_t;
/* Initialize conditional variable. */
_PROTOTYPE( ddekit_condvar_t * ddekit_condvar_init, (void));
ddekit_condvar_t * ddekit_condvar_init(void);
/* Uninitialize conditional variable. */
_PROTOTYPE( void ddekit_condvar_deinit, (ddekit_condvar_t *cvp));
void ddekit_condvar_deinit(ddekit_condvar_t *cvp);
/* Wait on a conditional variable. */
_PROTOTYPE( void ddekit_condvar_waiti, (ddekit_condvar_t *cvp,
ddekit_lock_t *mp));
void ddekit_condvar_waiti(ddekit_condvar_t *cvp, ddekit_lock_t *mp);
/* Wait on a conditional variable at most until a timeout expires. (UNIMPL) */
_PROTOTYPE( int ddekit_condvar_wait_timed, (ddekit_condvar_t *cvp,
ddekit_lock_t *mp, int timo));
int ddekit_condvar_wait_timed(ddekit_condvar_t *cvp, ddekit_lock_t *mp,
int timo);
/* Send signal to the next one waiting for condvar. */
_PROTOTYPE( void ddekit_condvar_signal, (ddekit_condvar_t *cvp));
void ddekit_condvar_signal(ddekit_condvar_t *cvp);
/* Send signal to all threads waiting for condvar. */
_PROTOTYPE( void ddekit_condvar_broadcast, (ddekit_condvar_t *cvp));
void ddekit_condvar_broadcast(ddekit_condvar_t *cvp);
#endif

2
include/ddekit/ddekit.h
View File

@@ -1,7 +1,7 @@
#ifndef _DDEKIT_DDEKIT_H
#define _DDEKIT_DDEKIT_H
#include <minix/ansi.h>
_PROTOTYPE( void ddekit_init, (void) );
void ddekit_init(void);
#endif

2
include/ddekit/initcall.h
View File

@@ -25,6 +25,6 @@ void __ddekit_add_initcall(struct __ddekit_initcall_s *dis);
__ddekit_add_initcall(&dis); }
/* Runs all registered initcalls. */
_PROTOTYPE (void ddekit_do_initcalls, (void));
void ddekit_do_initcalls(void);
#endif

11
include/ddekit/interrupt.h
View File

@@ -32,17 +32,16 @@
#include <ddekit/thread.h>
/** Attach to an interrupt */
_PROTOTYPE( ddekit_thread_t *ddekit_interrupt_attach,
( int irq, int shared, void(*thread_init)(void *),
void(*handler)(void *), void *priv) );
ddekit_thread_t *ddekit_interrupt_attach( int irq, int shared,
void(*thread_init)(void *), void(*handler)(void *), void *priv);
/* Detach from a previously attached interrupt. */
_PROTOTYPE( void ddekit_interrupt_detach, (int irq));
void ddekit_interrupt_detach(int irq);
/* Block interrupt. */
_PROTOTYPE( void ddekit_interrupt_disable, (int irq));
void ddekit_interrupt_disable(int irq);
/* Enable interrupt */
_PROTOTYPE( void ddekit_interrupt_enable, (int irq));
void ddekit_interrupt_enable(int irq);
#endif

14
include/ddekit/lock.h
View File

@@ -10,24 +10,24 @@ typedef struct ddekit_lock *ddekit_lock_t;
#define ddekit_lock_init ddekit_lock_init_unlocked
/* Initialize a DDEKit unlocked lock. */
_PROTOTYPE( void ddekit_lock_init_unlocked, (ddekit_lock_t *mtx));
void ddekit_lock_init_unlocked(ddekit_lock_t *mtx);
/* Initialize a DDEKit locked lock. */
_PROTOTYPE( void ddekit_lock_init_locked, (ddekit_lock_t *mtx));
void ddekit_lock_init_locked(ddekit_lock_t *mtx);
/* Uninitialize a DDEKit lock. */
_PROTOTYPE( void ddekit_lock_deinit, (ddekit_lock_t *mtx));
void ddekit_lock_deinit(ddekit_lock_t *mtx);
/* Acquire a lock. */
_PROTOTYPE( void ddekit_lock_lock, (ddekit_lock_t *mtx));
void ddekit_lock_lock(ddekit_lock_t *mtx);
/* Acquire a lock, non-blocking. */
_PROTOTYPE( int ddekit_lock_try_lock, (ddekit_lock_t *mtx));
int ddekit_lock_try_lock(ddekit_lock_t *mtx);
/* Unlock function. */
_PROTOTYPE( void ddekit_lock_unlock, (ddekit_lock_t *mtx));
void ddekit_lock_unlock(ddekit_lock_t *mtx);
/* Get lock owner. */
_PROTOTYPE( int ddekit_lock_owner, (ddekit_lock_t *mtx));
int ddekit_lock_owner(ddekit_lock_t *mtx);
#endif

29
include/ddekit/memory.h
View File

@@ -40,17 +40,16 @@
struct ddekit_slab;
/* Store user pointer in slab cache */
_PROTOTYPE( void ddekit_slab_set_data, (struct ddekit_slab * slab,
void *data));
void ddekit_slab_set_data(struct ddekit_slab * slab, void *data);
/* Read user pointer from slab cache */
_PROTOTYPE( void *ddekit_slab_get_data,(struct ddekit_slab * slab));
void *ddekit_slab_get_data(struct ddekit_slab * slab);
/* Allocate slab in slab cache */
_PROTOTYPE( void *ddekit_slab_alloc, (struct ddekit_slab * slab));
void *ddekit_slab_alloc(struct ddekit_slab * slab);
/* Allocate slab in slab cache */
_PROTOTYPE( void ddekit_slab_free, (struct ddekit_slab * slab, void *objp));
void ddekit_slab_free(struct ddekit_slab * slab, void *objp);
/*
* Setup page cache for all slabs
@@ -65,14 +64,14 @@ _PROTOTYPE( void ddekit_slab_free, (struct ddekit_slab * slab, void *objp));
* will be freed at the memory server. This page cache caches pages from all
* slabs.
*/
_PROTOTYPE( void ddekit_slab_setup_page_cache, (unsigned pages));
void ddekit_slab_setup_page_cache(unsigned pages);
/*
* Destroy slab cache
*
* slab: pointer to slab cache structure
*/
_PROTOTYPE( void ddekit_slab_destroy, (struct ddekit_slab * slab));
void ddekit_slab_destroy(struct ddekit_slab * slab);
/**
* Initialize slab cache
@@ -82,7 +81,7 @@ _PROTOTYPE( void ddekit_slab_destroy, (struct ddekit_slab * slab));
*
* \return pointer to new slab cache or 0 on error
*/
_PROTOTYPE( struct ddekit_slab * ddekit_slab_init,(unsigned size, int contiguous));
struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous);
/**********************
@@ -103,22 +102,20 @@ _PROTOTYPE( struct ddekit_slab * ddekit_slab_init,(unsigned size, int contiguous
* Allocated blocks have valid virt->phys mappings and are physically
* contiguous.
*/
_PROTOTYPE( void *ddekit_large_malloc, (int size));
void *ddekit_large_malloc(int size);
/**
* Free large memory block
*
* \param p pointer to memory block
*/
_PROTOTYPE( void ddekit_large_free, (void *p));
void ddekit_large_free(void *p);
/** FIXME
* contig_malloc() is the lowest-level allocator interface one could implement.
* we should consider to provide vmalloc() too. */
_PROTOTYPE( void *ddekit_contig_malloc,
(unsigned long size, unsigned long low,
unsigned long high, unsigned long alignment,
unsigned long boundary));
void *ddekit_contig_malloc(unsigned long size, unsigned long low,
unsigned long high, unsigned long alignment, unsigned long boundary);
/*****************************
@@ -134,13 +131,13 @@ _PROTOTYPE( void *ddekit_contig_malloc,
* The blocks allocated via this allocator CANNOT be used for DMA or other
* device operations, i.e., there exists no virt->phys mapping.
*/
_PROTOTYPE( void *ddekit_simple_malloc, (unsigned size));
void *ddekit_simple_malloc(unsigned size);
/**
* Free memory block via simple allocator
*
* \param p pointer to memory block
*/
_PROTOTYPE( void ddekit_simple_free, (void *p));
void ddekit_simple_free(void *p);
#endif

12
include/ddekit/minix/msg_queue.h
View File

@@ -7,16 +7,14 @@
struct ddekit_minix_msg_q;
_PROTOTYPE( void ddekit_minix_queue_msg, (message *m));
void ddekit_minix_queue_msg(message *m);
_PROTOTYPE( void ddekit_minix_rcv,
(struct ddekit_minix_msg_q * mq, message *m));
void ddekit_minix_rcv(struct ddekit_minix_msg_q * mq, message *m);
_PROTOTYPE( struct ddekit_minix_msg_q *ddekit_minix_create_msg_q,
(unsigned from, unsigned to));
struct ddekit_minix_msg_q *ddekit_minix_create_msg_q(unsigned from,
unsigned to);
_PROTOTYPE( void ddekit_minix_destroy_msg_q,
(struct ddekit_minix_msg_q *mq));
void ddekit_minix_destroy_msg_q(struct ddekit_minix_msg_q *mq);
#endif /* DDEKIT_SRC_MSG_QUEUE_H */

4
include/ddekit/panic.h
View File

@@ -8,11 +8,11 @@
/** Panic - print error message and enter the kernel debugger.
* \ingroup DDEKit_util
*/
_PROTOTYPE (void ddekit_panic, (char *fmt, ...));
void ddekit_panic(char *fmt, ...);
/** Print a debug message.
* \ingroup DDEKit_util
*/
_PROTOTYPE (void ddekit_debug, (char *fmt, ...));
void ddekit_debug(char *fmt, ...);
#endif

77
include/ddekit/pci.h
View File

@@ -24,15 +24,14 @@ typedef struct ddekit_pci_resource {
unsigned long flags;
} ddekit_pci_res_t;
_PROTOTYPE( void ddekit_pci_init, (void));
void ddekit_pci_init(void);
_PROTOTYPE( int ddekit_pci_get_device,(int nr, int *bus,
int *slot, int *func));
int ddekit_pci_get_device(int nr, int *bus, int *slot, int *func);
_PROTOTYPE( int ddekit_pci_read, (int bus, int slot, int func,
int pos, int len, ddekit_uint32_t *val));
_PROTOTYPE( int ddekit_pci_write, (int bus, int slot, int func,
int pos, int len, ddekit_uint32_t val));
int ddekit_pci_read(int bus, int slot, int func, int pos, int len,
ddekit_uint32_t *val);
int ddekit_pci_write(int bus, int slot, int func, int pos, int len,
ddekit_uint32_t val);
/** Read byte from PCI config space.
*
@@ -46,8 +45,8 @@ _PROTOTYPE( int ddekit_pci_write, (int bus, int slot, int func,
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_readb, (int bus, int slot,
int func, int pos, ddekit_uint8_t *val));
int ddekit_pci_readb(int bus, int slot, int func, int pos,
ddekit_uint8_t *val);
/** Read word from PCI config space.
*
@@ -61,8 +60,8 @@ _PROTOTYPE( int ddekit_pci_readb, (int bus, int slot,
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_readw, (int bus, int slot,
int func, int pos, ddekit_uint16_t *val));
int ddekit_pci_readw(int bus, int slot, int func, int pos,
ddekit_uint16_t *val);
/** Read dword from PCI config space.
*
@@ -76,8 +75,8 @@ _PROTOTYPE( int ddekit_pci_readw, (int bus, int slot,
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_readl, (int bus, int slot,
int func, int pos, ddekit_uint32_t *val));
int ddekit_pci_readl(int bus, int slot, int func, int pos,
ddekit_uint32_t *val);
/** Write byte to PCI config space.
*
@@ -91,8 +90,8 @@ _PROTOTYPE( int ddekit_pci_readl, (int bus, int slot,
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_writeb, (int bus, int slot,
int func, int pos, ddekit_uint8_t val));
int ddekit_pci_writeb(int bus, int slot, int func, int pos,
ddekit_uint8_t val);
/** Write word to PCI config space.
*
@@ -106,8 +105,8 @@ _PROTOTYPE( int ddekit_pci_writeb, (int bus, int slot,
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_writew, (int bus, int slot,
int func, int pos, ddekit_uint16_t val));
int ddekit_pci_writew(int bus, int slot, int func, int pos,
ddekit_uint16_t val);
/** Write word to PCI config space.
*
@@ -121,8 +120,8 @@ _PROTOTYPE( int ddekit_pci_writew, (int bus, int slot,
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_writel, (int bus, int slot,
int func, int pos, ddekit_uint32_t val));
int ddekit_pci_writel(int bus, int slot, int func, int pos,
ddekit_uint32_t val);
/** Find a PCI device.
*
@@ -141,77 +140,71 @@ _PROTOTYPE( int ddekit_pci_writel, (int bus, int slot,
* \return device a valid PCI device
* \return NULL if no device found
*/
_PROTOTYPE( struct ddekit_pci_dev * ddekit_pci_find_device,
(int *bus, int *slot, int *func, struct ddekit_pci_dev *start));
struct ddekit_pci_dev * ddekit_pci_find_device(int *bus, int *slot, int
*func, struct ddekit_pci_dev *start);
/** Enable PCI device
* \ingroup DDEKit_pci
*/
_PROTOTYPE( int ddekit_pci_enable_device, (struct ddekit_pci_dev *dev));
int ddekit_pci_enable_device(struct ddekit_pci_dev *dev);
/** Disable PCI device
* \ingroup DDEKit_pci
*/
_PROTOTYPE( int ddekit_pci_disable_device, (struct ddekit_pci_dev *dev));
int ddekit_pci_disable_device(struct ddekit_pci_dev *dev);
/** Enable bus-mastering for device.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( void ddekit_pci_set_master, (struct ddekit_pci_dev *dev));
void ddekit_pci_set_master(struct ddekit_pci_dev *dev);
/** Get device vendor ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_vendor,
(struct ddekit_pci_dev *dev));
unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev);
/** Get device ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_device_id,
(struct ddekit_pci_dev *dev));
unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev);
/** Get device subvendor ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_sub_vendor,
(struct ddekit_pci_dev *dev));
unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev);
/** Get subdevice ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_sub_device,
(struct ddekit_pci_dev *dev));
unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev);
/** Get device class ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned ddekit_pci_get_dev_class,
(struct ddekit_pci_dev *dev));
unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev);
/** Get device's IRQ number.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned long ddekit_pci_get_irq,
(struct ddekit_pci_dev *dev));
unsigned long ddekit_pci_get_irq(struct ddekit_pci_dev *dev);
/** Get device name.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( char *ddekit_pci_get_name, (struct ddekit_pci_dev *dev));
char *ddekit_pci_get_name(struct ddekit_pci_dev *dev);
/** Get device's slot name.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( char *ddekit_pci_get_slot_name, (struct ddekit_pci_dev *dev));
char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev);
/** Get one of the device's resources.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( ddekit_pci_res_t *ddekit_pci_get_resource,
(struct ddekit_pci_dev *dev, unsigned int idx));
ddekit_pci_res_t *ddekit_pci_get_resource(struct ddekit_pci_dev *dev,
unsigned int idx);
_PROTOTYPE( int ddekit_pci_irq_enable, (int bus, int slot,
int func, int pin, int *irq));
int ddekit_pci_irq_enable(int bus, int slot, int func, int pin, int
*irq);
#endif

20
include/ddekit/pgtab.h
View File

@@ -28,8 +28,8 @@ enum ddekit_pgtab_type
* \param pages number of pages in region
* \param type pgtab type for region
*/
_PROTOTYPE( void ddekit_pgtab_set_region,
(void *virt, ddekit_addr_t phys, int pages, int type));
void ddekit_pgtab_set_region(void *virt, ddekit_addr_t phys, int pages,
int type);
/**
@@ -39,8 +39,8 @@ _PROTOTYPE( void ddekit_pgtab_set_region,
* with the underlying mechanism and therefore can use this function that takes care
* of translating a size to an amount of pages.
*/
_PROTOTYPE( void ddekit_pgtab_set_region_with_size,
(void *virt, ddekit_addr_t phys, int size, int type));
void ddekit_pgtab_set_region_with_size(void *virt, ddekit_addr_t phys,
int size, int type);
/**
@@ -49,8 +49,7 @@ _PROTOTYPE( void ddekit_pgtab_set_region_with_size,
* \param virt virtual start address for region
* \param type pgtab type for region
*/
_PROTOTYPE( void ddekit_pgtab_clear_region,
(void *virt, int type));
void ddekit_pgtab_clear_region(void *virt, int type);
/**
* Get physical address for virtual address
@@ -59,7 +58,7 @@ _PROTOTYPE( void ddekit_pgtab_clear_region,
*
* \return physical address
*/
_PROTOTYPE( ddekit_addr_t ddekit_pgtab_get_physaddr, (const void *virt));
ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt);
/**
* Get virtual address for physical address
@@ -68,8 +67,7 @@ _PROTOTYPE( ddekit_addr_t ddekit_pgtab_get_physaddr, (const void *virt));
*
* \return virtual address
*/
_PROTOTYPE( ddekit_addr_t ddekit_pgtab_get_virtaddr,
(const ddekit_addr_t physical));
ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical);
/**
* Get type of VM region.
@@ -78,7 +76,7 @@ _PROTOTYPE( ddekit_addr_t ddekit_pgtab_get_virtaddr,
* \return VM region type
*/
_PROTOTYPE( int ddekit_pgtab_get_type, (const void *virt));
int ddekit_pgtab_get_type(const void *virt);
/**
* Get size of VM region.
@@ -87,6 +85,6 @@ _PROTOTYPE( int ddekit_pgtab_get_type, (const void *virt));
*
* \return VM region size (in bytes)
*/
_PROTOTYPE( int ddekit_pgtab_get_size, (const void *virt));
int ddekit_pgtab_get_size(const void *virt);
#endif

6
include/ddekit/printf.h
View File

@@ -7,17 +7,17 @@
/** Print message.
* \ingroup DDEKit_util
*/
_PROTOTYPE( int ddekit_print,(const char *));
int ddekit_print(const char *);
/** Print message with format.
* \ingroup DDEKit_util
*/
_PROTOTYPE( int ddekit_printf,(const char *fmt, ...));
int ddekit_printf(const char *fmt, ...);
/** Print message with format list.
* \ingroup DDEKit_util
*/
_PROTOTYPE( int ddekit_vprintf, (const char *fmt, va_list va));
int ddekit_vprintf(const char *fmt, va_list va);
/** Log function and message.
* \ingroup DDEKit_util

26
include/ddekit/resources.h
View File

@@ -9,21 +9,21 @@
* request/release an isa DMA-channel
*/
_PROTOTYPE( int ddekit_request_dma, (int nr));
_PROTOTYPE( int ddekit_release_dma, (int nr));
int ddekit_request_dma(int nr);
int ddekit_release_dma(int nr);
/*
* request/release an io-port range starting at addr start, lenght of count
*/
_PROTOTYPE( int ddekit_request_io, (ddekit_addr_t start, ddekit_addr_t count));
_PROTOTYPE( int ddekit_release_io, (ddekit_addr_t start, ddekit_addr_t count));
int ddekit_request_io(ddekit_addr_t start, ddekit_addr_t count);
int ddekit_release_io(ddekit_addr_t start, ddekit_addr_t count);
/*
* request an IO-Memory mapping from address start to vaddr of the length count
*/
_PROTOTYPE( int ddekit_request_mem,
(ddekit_addr_t start, ddekit_addr_t count, ddekit_addr_t *vaddr));
_PROTOTYPE( int ddekit_release_mem, (ddekit_addr_t start, ddekit_addr_t count));
int ddekit_request_mem(ddekit_addr_t start, ddekit_addr_t count,
ddekit_addr_t *vaddr);
int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t count);
/**
* Read I/O port (byte)
@@ -32,7 +32,7 @@ _PROTOTYPE( int ddekit_release_mem, (ddekit_addr_t start, ddekit_addr_t count));
*
* \return value read from port
*/
_PROTOTYPE( unsigned char dde_kit_inb, (ddekit_addr_t port));
unsigned char dde_kit_inb(ddekit_addr_t port);
/**
* Read I/O port (2-byte)
@@ -41,7 +41,7 @@ _PROTOTYPE( unsigned char dde_kit_inb, (ddekit_addr_t port));
*
* \return value read from port
*/
_PROTOTYPE( unsigned short dde_kit_inw, (ddekit_addr_t port));
unsigned short dde_kit_inw(ddekit_addr_t port);
/**
* Read I/O port (4-byte)
@@ -50,7 +50,7 @@ _PROTOTYPE( unsigned short dde_kit_inw, (ddekit_addr_t port));
*
* \return value read from port
*/
_PROTOTYPE( unsigned long dde_kit_inl, (ddekit_addr_t port));
unsigned long dde_kit_inl(ddekit_addr_t port);
/**
* Write I/O port (byte)
@@ -58,7 +58,7 @@ _PROTOTYPE( unsigned long dde_kit_inl, (ddekit_addr_t port));
* \param port port to write
* \param val value to write
*/
_PROTOTYPE( void dde_kit_outb, (ddekit_addr_t port, unsigned char val));
void dde_kit_outb(ddekit_addr_t port, unsigned char val);
/**
* Write I/O port (2-byte)
@@ -66,7 +66,7 @@ _PROTOTYPE( void dde_kit_outb, (ddekit_addr_t port, unsigned char val));
* \param port port to write
* \param val value to write
*/
_PROTOTYPE( void dde_kit_outw, (ddekit_addr_t port, unsigned short val));
void dde_kit_outw(ddekit_addr_t port, unsigned short val);
/**
* Write I/O port (4-byte)
@@ -74,7 +74,7 @@ _PROTOTYPE( void dde_kit_outw, (ddekit_addr_t port, unsigned short val));
* \param port port to write
* \param val value to write
*/
_PROTOTYPE( void dde_kit_outl, (ddekit_addr_t port, unsigned long val));
void dde_kit_outl(ddekit_addr_t port, unsigned long val);
#endif

12
include/ddekit/semaphore.h
View File

@@ -15,16 +15,16 @@ typedef struct ddekit_sem ddekit_sem_t;
*
* \param value initial semaphore counter
*/
_PROTOTYPE( ddekit_sem_t *ddekit_sem_init, (int value));
ddekit_sem_t *ddekit_sem_init(int value);
/** Uninitialize semaphore.
*
* \ingroup DDEKit_synchronization
*/
_PROTOTYPE( void ddekit_sem_deinit, (ddekit_sem_t *sem));
void ddekit_sem_deinit(ddekit_sem_t *sem);
/** Semaphore down method. */
_PROTOTYPE( void ddekit_sem_down, (ddekit_sem_t *sem));
void ddekit_sem_down(ddekit_sem_t *sem);
/** Semaphore down method, non-blocking.
*
@@ -33,7 +33,7 @@ _PROTOTYPE( void ddekit_sem_down, (ddekit_sem_t *sem));
* \return 0 success
* \return !=0 would block
*/
_PROTOTYPE( int ddekit_sem_down_try, (ddekit_sem_t *sem));
int ddekit_sem_down_try(ddekit_sem_t *sem);
/** Semaphore down with timeout.
*
@@ -42,12 +42,12 @@ _PROTOTYPE( int ddekit_sem_down_try, (ddekit_sem_t *sem));
* \return 0 success
* \return !=0 would block
*/
_PROTOTYPE( int ddekit_sem_down_timed, (ddekit_sem_t *sem, int timo));
int ddekit_sem_down_timed(ddekit_sem_t *sem, int timo);
/** Semaphore up method.
*
* \ingroup DDEKit_synchronization
*/
_PROTOTYPE( void ddekit_sem_up, (ddekit_sem_t *sem));
void ddekit_sem_up(ddekit_sem_t *sem);
#endif

41
include/ddekit/thread.h
View File

@@ -22,14 +22,14 @@ typedef struct ddekit_thread ddekit_thread_t;
* \param arg optional argument to thread function, set to NULL if not needed
* \param name internal thread name
*/
_PROTOTYPE( ddekit_thread_t *ddekit_thread_create,
(void (*fun)(void *), void *arg, const char *name));
ddekit_thread_t *ddekit_thread_create(void (*fun)(void *), void *arg,
const char *name);
/** Reference to own DDEKit thread id.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( ddekit_thread_t *ddekit_thread_myself, (void));
ddekit_thread_t *ddekit_thread_myself(void);
/** Initialize thread with given name.
*
@@ -39,7 +39,7 @@ _PROTOTYPE( ddekit_thread_t *ddekit_thread_myself, (void));
* \ref ddekit_thread_create. This enables such threads to be handled as if they
* were DDEKit threads.
*/
_PROTOTYPE( ddekit_thread_t *ddekit_thread_setup_myself, (const char *name));
ddekit_thread_t *ddekit_thread_setup_myself(const char *name);
/** Get TLS data for a specific thread.
*
@@ -47,7 +47,7 @@ _PROTOTYPE( ddekit_thread_t *ddekit_thread_setup_myself, (const char *name));
*
* \return Pointer to TLS data of this thread.
*/
_PROTOTYPE( void *ddekit_thread_get_data, (ddekit_thread_t *thread));
void *ddekit_thread_get_data(ddekit_thread_t *thread);
/** Get TLS data for current thread.
*
@@ -58,7 +58,7 @@ _PROTOTYPE( void *ddekit_thread_get_data, (ddekit_thread_t *thread));
*
* \return Pointer to TLS data of current thread.
*/
_PROTOTYPE( void *ddekit_thread_get_my_data, (void));
void *ddekit_thread_get_my_data(void);
/** Set TLS data for specific thread.
*
@@ -67,8 +67,7 @@ _PROTOTYPE( void *ddekit_thread_get_my_data, (void));
* \param thread DDEKit thread
* \param data pointer to thread data
*/
_PROTOTYPE( void ddekit_thread_set_data, (ddekit_thread_t *thread,
void *data));
void ddekit_thread_set_data(ddekit_thread_t *thread, void *data);
/** Set TLS data for current thread.
*
@@ -76,7 +75,7 @@ _PROTOTYPE( void ddekit_thread_set_data, (ddekit_thread_t *thread,
*
* \param data pointer to thread data
*/
_PROTOTYPE( void ddekit_thread_set_my_data, (void *data));
void ddekit_thread_set_my_data(void *data);
/** Sleep for some miliseconds.
*
@@ -84,7 +83,7 @@ _PROTOTYPE( void ddekit_thread_set_my_data, (void *data));
*
* \param msecs time to sleep in ms.
*/
_PROTOTYPE( void ddekit_thread_msleep, (unsigned long msecs));
void ddekit_thread_msleep(unsigned long msecs);
/** Sleep for some microseconds.
*
@@ -92,7 +91,7 @@ _PROTOTYPE( void ddekit_thread_msleep, (unsigned long msecs));
*
* \param usecs time to sleep in µs.
*/
_PROTOTYPE( void ddekit_thread_usleep, (unsigned long usecs));
void ddekit_thread_usleep(unsigned long usecs);
/** Sleep for some nanoseconds.
*
@@ -100,37 +99,37 @@ _PROTOTYPE( void ddekit_thread_usleep, (unsigned long usecs));
*
* \param usecs time to sleep in ns.
*/
_PROTOTYPE( void ddekit_thread_nsleep, (unsigned long nsecs));
void ddekit_thread_nsleep(unsigned long nsecs);
/** Sleep until a lock becomes unlocked.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_sleep, (ddekit_lock_t *lock));
void ddekit_thread_sleep(ddekit_lock_t *lock);
/** Wakeup a waiting thread.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_wakeup, (ddekit_thread_t *thread));
void ddekit_thread_wakeup(ddekit_thread_t *thread);
/** Terminate a thread
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_exit, (void) __attribute__((noreturn)));
void ddekit_thread_exit(void) __attribute__((noreturn));
/** Terminate a thread
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_terminate, (ddekit_thread_t *thread));
void ddekit_thread_terminate(ddekit_thread_t *thread);
/** Get the name, a thread registered with DDEKit.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( const char *ddekit_thread_get_name, (ddekit_thread_t *thread));
const char *ddekit_thread_get_name(ddekit_thread_t *thread);
/** Get unique ID of a DDEKit thread.
*
@@ -141,24 +140,24 @@ _PROTOTYPE( const char *ddekit_thread_get_name, (ddekit_thread_t *thread));
* However, applications might want to get some kind of ID related
* to a ddekit_thread, for instance to use it as a Linux-like PID.
*/
_PROTOTYPE( int ddekit_thread_get_id, (ddekit_thread_t *thread));
int ddekit_thread_get_id(ddekit_thread_t *thread);
/** Hint that this thread is done and may be scheduled somehow.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_schedule, (void));
void ddekit_thread_schedule(void);
/** Hint that this thread is done and may be scheduled somehow.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_yield, (void));
void ddekit_yield(void);
/** Initialize DDEKit thread subsystem.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_init_threads, (void));
void ddekit_init_threads(void);
#endif

12
include/ddekit/timer.h
View File

@@ -22,14 +22,14 @@
* \return >=0 valid timer ID
* \return < 0 error
*/
_PROTOTYPE( int ddekit_add_timer,
(void (*fn)(void *), void *args, unsigned long timeout));
int ddekit_add_timer(void (*fn)(void *), void *args, unsigned long
timeout);
/** Delete timer with the corresponding timer id.
*
* \ingroup DDEKit_timer
*/
_PROTOTYPE( int ddekit_del_timer, (int timer));
int ddekit_del_timer(int timer);
/** Check whether a timer is pending
*
@@ -37,16 +37,16 @@ _PROTOTYPE( int ddekit_del_timer, (int timer));
*
* Linux needs this.
*/
_PROTOTYPE( int ddekit_timer_pending, (int timer));
int ddekit_timer_pending(int timer);
/** Initialization function, startup timer thread
*
* \ingroup DDEKit_timer
*/
_PROTOTYPE( void ddekit_init_timers, (void));
void ddekit_init_timers(void);
/** Get the timer thread.
*/
_PROTOTYPE( ddekit_thread_t *ddekit_get_timer_thread, (void));
ddekit_thread_t *ddekit_get_timer_thread(void);
#endif

18
include/ddekit/usb.h
View File

@@ -78,20 +78,18 @@ struct ddekit_usb_urb {
void *ddekit_priv;
};
_PROTOTYPE( int ddekit_usb_dev_set_data,
(struct ddekit_usb_dev *dev, void *data));
_PROTOTYPE( void *ddekit_usb_dev_get_data, (struct ddekit_usb_dev *dev));
_PROTOTYPE( void ddekit_usb_get_device_id, (struct ddekit_usb_dev *dev,
struct ddekit_usb_device_id *id));
_PROTOTYPE( int ddekit_usb_submit_urb, (struct ddekit_usb_urb *d_urb));
_PROTOTYPE( int ddekit_usb_cancle_urb, (struct ddekit_usb_urb *d_urb));
int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data);
void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev);
void ddekit_usb_get_device_id(struct ddekit_usb_dev *dev, struct
ddekit_usb_device_id *id);
int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb);
int ddekit_usb_cancle_urb(struct ddekit_usb_urb *d_urb);
/*
* This one is only implemented for the client side. For the server side is
* has to be implemented in the DDELinux/FBSD part.
*/
_PROTOTYPE( int ddekit_usb_init, (struct ddekit_usb_driver *drv,
ddekit_usb_malloc_fn *_m,
ddekit_usb_free_fn *_f));
int ddekit_usb_init(struct ddekit_usb_driver *drv, ddekit_usb_malloc_fn
*_m, ddekit_usb_free_fn *_f);
#endif

10
include/env.h
View File

@@ -1,9 +1,9 @@
#ifdef __NBSD_LIBC
#include <minix/ansi.h>
#endif
_PROTOTYPE( int env_parse, (char *env, char *fmt, int field,
long *param, long min, long max) );
_PROTOTYPE( void env_panic, (char *env) );
_PROTOTYPE( int env_prefix, (char *env, char *prefix) );
_PROTOTYPE( int env_memory_parse, (struct memory *chunks, int nchunks) );
int env_parse(char *env, char *fmt, int field, long *param, long min,
long max);
void env_panic(char *env);
int env_prefix(char *env, char *prefix);
int env_memory_parse(struct memory *chunks, int nchunks);

12
include/lib.h
View File

@@ -29,11 +29,11 @@
#include <minix/ipc.h>
_PROTOTYPE( int __execve, (const char *_path, char *const _argv[],
char *const _envp[], int _nargs, int _nenvps) );
_PROTOTYPE( int _syscall, (endpoint_t _who, int _syscallnr, message *_msgptr) );
_PROTOTYPE( void _loadname, (const char *_name, message *_msgptr) );
_PROTOTYPE( int _len, (const char *_s) );
_PROTOTYPE( void _begsig, (int _dummy) );
int __execve(const char *_path, char *const _argv[], char *const
_envp[], int _nargs, int _nenvps);
int _syscall(endpoint_t _who, int _syscallnr, message *_msgptr);
void _loadname(const char *_name, message *_msgptr);
int _len(const char *_s);
void _begsig(int _dummy);
#endif /* _LIB_H */

14
include/minix/ansi.h
View File

@@ -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

28
include/minix/audio_fw.h
View File

@@ -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);

40
include/minix/blockdriver.h
View File

@@ -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. */

12
include/minix/blockdriver_mt.h
View File

@@ -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 */

46
include/minix/chardriver.h
View File

@@ -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 */

2
include/minix/cpufeature.h
View File

@@ -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

2
include/minix/crtso.h
View File

@@ -3,6 +3,6 @@
#ifndef _MINIX_CRTSO_H
#define _MINIX_CRTSO_H
_PROTOTYPE( void _minix_unmapzero, (void));
void _minix_unmapzero(void);
#endif

20
include/minix/devman.h
View File

@@ -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
include/minix/drvlib.h
View File

@@ -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

48
include/minix/ds.h
View File

@@ -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 */

18
include/minix/fslib.h
View File

@@ -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);

44
include/minix/hgfs.h
View File

@@ -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 */

16
include/minix/ipc.h
View File

@@ -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 */

28
include/minix/minlib.h
View File

@@ -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

108
include/minix/mthread.h
View File

@@ -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

5
include/minix/netdriver.h
View File

@@ -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 */

2
include/minix/optset.h
View File

@@ -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 */

13
include/minix/profile.h
View File

@@ -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 */

2
include/minix/rs.h
View File

@@ -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

29
include/minix/safecopies.h
View File

@@ -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) \

13
include/minix/sched.h
View File

@@ -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 */

83
include/minix/sef.h
View File

@@ -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

4
include/minix/spin.h
View File

@@ -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. */

3
include/minix/sysinfo.h
View File

@@ -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 */

246
include/minix/syslib.h
View File

@@ -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 */

58
include/minix/sysutil.h
View File

@@ -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); }

9
include/minix/timers.h
View File

@@ -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 */

56
include/minix/vm.h
View File

@@ -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 */

8
include/sys/tree.h
View File

@@ -112,8 +112,6 @@ struct { \
/* Generates prototypes and inline functions */
#define SPLAY_PROTOTYPE(name, type, field, cmp) \
void name##_SPLAY(struct name *, struct type *); \
void name##_SPLAY_MINMAX(struct name *, int); \
struct type *name##_SPLAY_INSERT(struct name *, struct type *); \
struct type *name##_SPLAY_REMOVE(struct name *, struct type *); \
@@ -374,12 +372,6 @@ struct { \
} while (/*CONSTCOND*/ 0)
/* Generates prototypes and inline functions */
#define RB_PROTOTYPE(name, type, field, cmp) \
RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
#define RB_PROTOTYPE_STATIC(name, type, field, cmp) \
RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __unused static)
#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
attr void name##_RB_INSERT_COLOR(struct name *, struct type *); \
attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
attr struct type *name##_RB_REMOVE(struct name *, struct type *); \
attr struct type *name##_RB_INSERT(struct name *, struct type *); \

8
include/timers.h
View File

@@ -58,10 +58,10 @@ typedef struct timer
* can be used to operate on the lists of timers. Adding a timer to a list
* automatically takes care of removing it.
*/
_PROTOTYPE( clock_t tmrs_clrtimer, (timer_t **tmrs, timer_t *tp, clock_t *new_head) );
_PROTOTYPE( void tmrs_exptimers, (timer_t **tmrs, clock_t now, clock_t *new_head) );
_PROTOTYPE( clock_t tmrs_settimer, (timer_t **tmrs, timer_t *tp,
clock_t exp_time, tmr_func_t watchdog, clock_t *new_head) );
clock_t tmrs_clrtimer(timer_t **tmrs, timer_t *tp, clock_t *new_head);
void tmrs_exptimers(timer_t **tmrs, clock_t now, clock_t *new_head);
clock_t tmrs_settimer(timer_t **tmrs, timer_t *tp, clock_t exp_time,
tmr_func_t watchdog, clock_t *new_head);
#define PRINT_STATS(cum_spenttime, cum_instances) { \
if(ex64hi(cum_spenttime)) { util_stacktrace(); printf(" ( ??? %lu %lu)\n", \