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

retire PUBLIC, PRIVATE and FORWARD

Browse Source
This commit is contained in:
Ben Gras
2012-03-25 20:25:53 +02:00
parent 6a73e85ad1
commit 7336a67dfe
603 changed files with 5776 additions and 5779 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
lib/libaudiodriver/audio_fw.c
View File

@@ -47,43 +47,43 @@
#include <minix/ds.h>
FORWARD int msg_open(int minor_dev_nr);
FORWARD int msg_close(int minor_dev_nr);
FORWARD int msg_ioctl(const message *m_ptr);
FORWARD void msg_write(const message *m_ptr);
FORWARD void msg_read(message *m_ptr);
FORWARD void msg_hardware(void);
FORWARD void msg_status(message *m_ptr);
FORWARD int init_driver(void);
FORWARD int open_sub_dev(int sub_dev_nr, int operation);
FORWARD int close_sub_dev(int sub_dev_nr);
FORWARD void handle_int_write(int sub_dev_nr);
FORWARD void handle_int_read(int sub_dev_nr);
FORWARD void data_to_user(sub_dev_t *sub_dev_ptr);
FORWARD void data_from_user(sub_dev_t *sub_dev_ptr);
FORWARD int init_buffers(sub_dev_t *sub_dev_ptr);
FORWARD int get_started(sub_dev_t *sub_dev_ptr);
FORWARD void reply(int code, int replyee, int process,int status);
FORWARD int io_ctl_length(int io_request);
FORWARD special_file_t* get_special_file(int minor_dev_nr);
FORWARD void tell_dev(vir_bytes buf, size_t size, int pci_bus, int
static int msg_open(int minor_dev_nr);
static int msg_close(int minor_dev_nr);
static int msg_ioctl(const message *m_ptr);
static void msg_write(const message *m_ptr);
static void msg_read(message *m_ptr);
static void msg_hardware(void);
static void msg_status(message *m_ptr);
static int init_driver(void);
static int open_sub_dev(int sub_dev_nr, int operation);
static int close_sub_dev(int sub_dev_nr);
static void handle_int_write(int sub_dev_nr);
static void handle_int_read(int sub_dev_nr);
static void data_to_user(sub_dev_t *sub_dev_ptr);
static void data_from_user(sub_dev_t *sub_dev_ptr);
static int init_buffers(sub_dev_t *sub_dev_ptr);
static int get_started(sub_dev_t *sub_dev_ptr);
static void reply(int code, int replyee, int process,int status);
static int io_ctl_length(int io_request);
static special_file_t* get_special_file(int minor_dev_nr);
static void tell_dev(vir_bytes buf, size_t size, int pci_bus, int
pci_dev, int pci_func);
PRIVATE char io_ctl_buf[_IOCPARM_MASK];
PRIVATE int irq_hook_id = 0; /* id of irq hook at the kernel */
PRIVATE int irq_hook_set = FALSE;
PRIVATE int device_available = 0;/*todo*/
static char io_ctl_buf[_IOCPARM_MASK];
static int irq_hook_id = 0; /* id of irq hook at the kernel */
static int irq_hook_set = FALSE;
static int device_available = 0;/*todo*/
/* SEF functions and variables. */
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
static void sef_local_startup(void);
static int sef_cb_init_fresh(int type, sef_init_info_t *info);
static void sef_cb_signal_handler(int signo);
EXTERN int sef_cb_lu_prepare(int state);
EXTERN int sef_cb_lu_state_isvalid(int state);
EXTERN void sef_cb_lu_state_dump(int state);
PUBLIC int is_status_msg_expected = FALSE;
int is_status_msg_expected = FALSE;
PUBLIC int main(void)
int main(void)
{
int r, caller;
message mess, repl_mess;
@@ -180,7 +180,7 @@ PUBLIC int main(void)
/*===========================================================================*
* sef_local_startup *
*===========================================================================*/
PRIVATE void sef_local_startup()
static void sef_local_startup()
{
/* Register init callbacks. */
sef_setcb_init_fresh(sef_cb_init_fresh);
@@ -202,13 +202,13 @@ PRIVATE void sef_local_startup()
/*===========================================================================*
* sef_cb_init_fresh *
*===========================================================================*/
PRIVATE int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
{
/* Initialize the audio driver framework. */
return init_driver();
}
PRIVATE int init_driver(void) {
static int init_driver(void) {
u32_t i; char irq;
static int executed = 0;
sub_dev_t* sub_dev_ptr;
@@ -263,7 +263,7 @@ PRIVATE int init_driver(void) {
/*===========================================================================*
* sef_cb_signal_handler *
*===========================================================================*/
PRIVATE void sef_cb_signal_handler(int signo)
static void sef_cb_signal_handler(int signo)
{
int i;
char irq;
@@ -289,7 +289,7 @@ PRIVATE void sef_cb_signal_handler(int signo)
}
}
PRIVATE int msg_open (int minor_dev_nr) {
static int msg_open (int minor_dev_nr) {
int r, read_chan, write_chan, io_ctl;
special_file_t* special_file_ptr;
@@ -341,7 +341,7 @@ PRIVATE int msg_open (int minor_dev_nr) {
}
PRIVATE int open_sub_dev(int sub_dev_nr, int dma_mode) {
static int open_sub_dev(int sub_dev_nr, int dma_mode) {
sub_dev_t* sub_dev_ptr;
sub_dev_ptr = &sub_dev[sub_dev_nr];
@@ -377,7 +377,7 @@ PRIVATE int open_sub_dev(int sub_dev_nr, int dma_mode) {
}
PRIVATE int msg_close(int minor_dev_nr) {
static int msg_close(int minor_dev_nr) {
int r, read_chan, write_chan, io_ctl;
special_file_t* special_file_ptr;
@@ -412,7 +412,7 @@ PRIVATE int msg_close(int minor_dev_nr) {
}
PRIVATE int close_sub_dev(int sub_dev_nr) {
static int close_sub_dev(int sub_dev_nr) {
sub_dev_t *sub_dev_ptr;
sub_dev_ptr = &sub_dev[sub_dev_nr];
if (sub_dev_ptr->DmaMode == DEV_WRITE_S && !sub_dev_ptr->OutOfData) {
@@ -436,7 +436,7 @@ PRIVATE int close_sub_dev(int sub_dev_nr) {
}
PRIVATE int msg_ioctl(const message *m_ptr)
static int msg_ioctl(const message *m_ptr)
{
int status, len, chan;
sub_dev_t *sub_dev_ptr;
@@ -497,7 +497,7 @@ PRIVATE int msg_ioctl(const message *m_ptr)
}
PRIVATE void msg_write(const message *m_ptr)
static void msg_write(const message *m_ptr)
{
int chan; sub_dev_t *sub_dev_ptr;
special_file_t* special_file_ptr;
@@ -545,7 +545,7 @@ PRIVATE void msg_write(const message *m_ptr)
}
PRIVATE void msg_read(message *m_ptr)
static void msg_read(message *m_ptr)
{
int chan; sub_dev_t *sub_dev_ptr;
special_file_t* special_file_ptr;
@@ -595,7 +595,7 @@ PRIVATE void msg_read(message *m_ptr)
}
PRIVATE void msg_hardware(void) {
static void msg_hardware(void) {
u32_t i;
@@ -621,7 +621,7 @@ PRIVATE void msg_hardware(void) {
}
PRIVATE void msg_status(message *m_ptr)
static void msg_status(message *m_ptr)
{
int i;
@@ -651,7 +651,7 @@ PRIVATE void msg_status(message *m_ptr)
}
/* handle interrupt for specified sub device; DmaMode == DEV_WRITE_S*/
PRIVATE void handle_int_write(int sub_dev_nr)
static void handle_int_write(int sub_dev_nr)
{
sub_dev_t *sub_dev_ptr;
@@ -704,7 +704,7 @@ PRIVATE void handle_int_write(int sub_dev_nr)
/* handle interrupt for specified sub device; DmaMode == DEV_READ_S */
PRIVATE void handle_int_read(int sub_dev_nr)
static void handle_int_read(int sub_dev_nr)
{
sub_dev_t *sub_dev_ptr;
@@ -755,7 +755,7 @@ PRIVATE void handle_int_read(int sub_dev_nr)
}
PRIVATE int get_started(sub_dev_t *sub_dev_ptr) {
static int get_started(sub_dev_t *sub_dev_ptr) {
u32_t i;
/* enable interrupt messages from MINIX */
@@ -775,7 +775,7 @@ PRIVATE int get_started(sub_dev_t *sub_dev_ptr) {
}
PRIVATE void data_from_user(sub_dev_t *subdev)
static void data_from_user(sub_dev_t *subdev)
{
int r;
message m;
@@ -845,7 +845,7 @@ PRIVATE void data_from_user(sub_dev_t *subdev)
}
PRIVATE void data_to_user(sub_dev_t *sub_dev_ptr)
static void data_to_user(sub_dev_t *sub_dev_ptr)
{
int r;
message m;
@@ -902,7 +902,7 @@ PRIVATE void data_to_user(sub_dev_t *sub_dev_ptr)
sub_dev_ptr->RevivePending = 0;
}
PRIVATE int init_buffers(sub_dev_t *sub_dev_ptr)
static int init_buffers(sub_dev_t *sub_dev_ptr)
{
#if (CHIP == INTEL)
char *base;
@@ -961,7 +961,7 @@ PRIVATE int init_buffers(sub_dev_t *sub_dev_ptr)
}
PRIVATE void reply(int code, int replyee, int process, int status) {
static void reply(int code, int replyee, int process, int status) {
message m;
m.m_type = code; /* DEV_REVIVE */
@@ -971,13 +971,13 @@ PRIVATE void reply(int code, int replyee, int process, int status) {
}
PRIVATE int io_ctl_length(int io_request) {
static int io_ctl_length(int io_request) {
io_request >>= 16;
return io_request & _IOCPARM_MASK;
}
PRIVATE special_file_t* get_special_file(int minor_dev_nr) {
static special_file_t* get_special_file(int minor_dev_nr) {
int i;
for(i = 0; i < drv.NrOfSpecialFiles; i++) {
@@ -992,7 +992,7 @@ PRIVATE special_file_t* get_special_file(int minor_dev_nr) {
return NULL;
}
PRIVATE void tell_dev(buf, size, pci_bus, pci_dev, pci_func)
static void tell_dev(buf, size, pci_bus, pci_dev, pci_func)
vir_bytes buf;
size_t size;
int pci_bus;

12
lib/libaudiodriver/liveupdate.c
View File

@@ -9,9 +9,9 @@ EXTERN int is_status_msg_expected;
*/
/* State management helpers */
PRIVATE int is_read_pending;
PRIVATE int is_write_pending;
PRIVATE void load_state_info(void)
static int is_read_pending;
static int is_write_pending;
static void load_state_info(void)
{
int i, dma_mode, found_pending;
@@ -44,7 +44,7 @@ PRIVATE void load_state_info(void)
/*===========================================================================*
* sef_cb_lu_prepare *
*===========================================================================*/
PUBLIC int sef_cb_lu_prepare(int state)
int sef_cb_lu_prepare(int state)
{
int is_ready;
@@ -81,7 +81,7 @@ PUBLIC int sef_cb_lu_prepare(int state)
/*===========================================================================*
* sef_cb_lu_state_isvalid *
*===========================================================================*/
PUBLIC int sef_cb_lu_state_isvalid(int state)
int sef_cb_lu_state_isvalid(int state)
{
return SEF_LU_STATE_IS_STANDARD(state) || AUDIO_STATE_IS_CUSTOM(state);
}
@@ -89,7 +89,7 @@ PUBLIC int sef_cb_lu_state_isvalid(int state)
/*===========================================================================*
* sef_cb_lu_state_dump *
*===========================================================================*/
PUBLIC void sef_cb_lu_state_dump(int state)
void sef_cb_lu_state_dump(int state)
{
/* Load state information. */
load_state_info();

30
lib/libblockdriver/driver.c
View File

@@ -48,13 +48,13 @@
#include "trace.h"
/* Management data for opened devices. */
PRIVATE int open_devs[MAX_NR_OPEN_DEVICES];
PRIVATE int next_open_devs_slot = 0;
static int open_devs[MAX_NR_OPEN_DEVICES];
static int next_open_devs_slot = 0;
/*===========================================================================*
* clear_open_devs *
*===========================================================================*/
PRIVATE void clear_open_devs(void)
static void clear_open_devs(void)
{
/* Reset the set of previously opened minor devices. */
next_open_devs_slot = 0;
@@ -63,7 +63,7 @@ PRIVATE void clear_open_devs(void)
/*===========================================================================*
* is_open_dev *
*===========================================================================*/
PRIVATE int is_open_dev(int device)
static int is_open_dev(int device)
{
/* Check whether the given minor device has previously been opened. */
int i;
@@ -78,7 +78,7 @@ PRIVATE int is_open_dev(int device)
/*===========================================================================*
* set_open_dev *
*===========================================================================*/
PRIVATE void set_open_dev(int device)
static void set_open_dev(int device)
{
/* Mark the given minor device as having been opened. */
@@ -92,7 +92,7 @@ PRIVATE void set_open_dev(int device)
/*===========================================================================*
* blockdriver_announce *
*===========================================================================*/
PUBLIC void blockdriver_announce(int type)
void blockdriver_announce(int type)
{
/* Announce we are up after a fresh start or a restart. */
int r;
@@ -130,7 +130,7 @@ PUBLIC void blockdriver_announce(int type)
/*===========================================================================*
* blockdriver_reply *
*===========================================================================*/
PUBLIC void blockdriver_reply(message *m_ptr, int ipc_status, int reply)
void blockdriver_reply(message *m_ptr, int ipc_status, int reply)
{
/* Reply to a block request sent to the driver. */
endpoint_t caller_e;
@@ -167,7 +167,7 @@ PUBLIC void blockdriver_reply(message *m_ptr, int ipc_status, int reply)
/*===========================================================================*
* do_open *
*===========================================================================*/
PRIVATE int do_open(struct blockdriver *bdp, message *mp)
static int do_open(struct blockdriver *bdp, message *mp)
{
/* Open a minor device. */
@@ -177,7 +177,7 @@ PRIVATE int do_open(struct blockdriver *bdp, message *mp)
/*===========================================================================*
* do_close *
*===========================================================================*/
PRIVATE int do_close(struct blockdriver *bdp, message *mp)
static int do_close(struct blockdriver *bdp, message *mp)
{
/* Close a minor device. */
@@ -187,7 +187,7 @@ PRIVATE int do_close(struct blockdriver *bdp, message *mp)
/*===========================================================================*
* do_rdwt *
*===========================================================================*/
PRIVATE int do_rdwt(struct blockdriver *bdp, message *mp)
static int do_rdwt(struct blockdriver *bdp, message *mp)
{
/* Carry out a single read or write request. */
iovec_t iovec1;
@@ -216,7 +216,7 @@ PRIVATE int do_rdwt(struct blockdriver *bdp, message *mp)
/*===========================================================================*
* do_vrdwt *
*===========================================================================*/
PRIVATE int do_vrdwt(struct blockdriver *bdp, message *mp, thread_id_t id)
static int do_vrdwt(struct blockdriver *bdp, message *mp, thread_id_t id)
{
/* Carry out an device read or write to/from a vector of buffers. */
iovec_t iovec[NR_IOREQS];
@@ -257,7 +257,7 @@ PRIVATE int do_vrdwt(struct blockdriver *bdp, message *mp, thread_id_t id)
/*===========================================================================*
* do_dioctl *
*===========================================================================*/
PRIVATE int do_dioctl(struct blockdriver *bdp, dev_t minor,
static int do_dioctl(struct blockdriver *bdp, dev_t minor,
unsigned int request, endpoint_t endpt, cp_grant_id_t grant)
{
/* Carry out a disk-specific I/O control request. */
@@ -307,7 +307,7 @@ PRIVATE int do_dioctl(struct blockdriver *bdp, dev_t minor,
/*===========================================================================*
* do_ioctl *
*===========================================================================*/
PRIVATE int do_ioctl(struct blockdriver *bdp, message *mp)
static int do_ioctl(struct blockdriver *bdp, message *mp)
{
/* Carry out an I/O control request. We forward block trace control requests
* to the tracing module, and handle setting/getting partitions when the driver
@@ -355,7 +355,7 @@ PRIVATE int do_ioctl(struct blockdriver *bdp, message *mp)
/*===========================================================================*
* blockdriver_handle_notify *
*===========================================================================*/
PUBLIC void blockdriver_handle_notify(struct blockdriver *bdp, message *m_ptr)
void blockdriver_handle_notify(struct blockdriver *bdp, message *m_ptr)
{
/* Take care of the notifications (interrupt and clock messages) by calling
* the appropiate callback functions. Never send a reply.
@@ -382,7 +382,7 @@ PUBLIC void blockdriver_handle_notify(struct blockdriver *bdp, message *m_ptr)
/*===========================================================================*
* blockdriver_handle_request *
*===========================================================================*/
PUBLIC int blockdriver_handle_request(struct blockdriver *bdp, message *m_ptr,
int blockdriver_handle_request(struct blockdriver *bdp, message *m_ptr,
thread_id_t id)
{
/* Call the appropiate driver function, based on the type of request. Return

46
lib/libblockdriver/driver_mt.c
View File

@@ -53,20 +53,20 @@ typedef struct {
mthread_rwlock_t barrier;
} device_t;
PRIVATE struct blockdriver *bdtab;
PRIVATE int running = FALSE;
static struct blockdriver *bdtab;
static int running = FALSE;
PRIVATE mthread_key_t worker_key;
static mthread_key_t worker_key;
PRIVATE device_t device[MAX_DEVICES];
static device_t device[MAX_DEVICES];
PRIVATE worker_t *exited[MAX_THREADS];
PRIVATE int num_exited = 0;
static worker_t *exited[MAX_THREADS];
static int num_exited = 0;
/*===========================================================================*
* enqueue *
*===========================================================================*/
PRIVATE void enqueue(device_t *dp, const message *m_src, int ipc_status)
static void enqueue(device_t *dp, const message *m_src, int ipc_status)
{
/* Enqueue a message into the device's queue, and signal the event.
* Must be called from the master thread.
@@ -81,7 +81,7 @@ PRIVATE void enqueue(device_t *dp, const message *m_src, int ipc_status)
/*===========================================================================*
* try_dequeue *
*===========================================================================*/
PRIVATE int try_dequeue(device_t *dp, message *m_dst, int *ipc_status)
static int try_dequeue(device_t *dp, message *m_dst, int *ipc_status)
{
/* See if a message can be dequeued from the current worker thread's device
* queue. If so, dequeue the message and return TRUE. If not, return FALSE.
@@ -94,7 +94,7 @@ PRIVATE int try_dequeue(device_t *dp, message *m_dst, int *ipc_status)
/*===========================================================================*
* dequeue *
*===========================================================================*/
PRIVATE int dequeue(device_t *dp, worker_t *wp, message *m_dst,
static int dequeue(device_t *dp, worker_t *wp, message *m_dst,
int *ipc_status)
{
/* Dequeue a message from the current worker thread's device queue. Block the
@@ -119,7 +119,7 @@ PRIVATE int dequeue(device_t *dp, worker_t *wp, message *m_dst,
/*===========================================================================*
* is_transfer_req *
*===========================================================================*/
PRIVATE int is_transfer_req(int type)
static int is_transfer_req(int type)
{
/* Return whether the given block device request is a transfer request.
*/
@@ -139,7 +139,7 @@ PRIVATE int is_transfer_req(int type)
/*===========================================================================*
* worker_thread *
*===========================================================================*/
PRIVATE void *worker_thread(void *param)
static void *worker_thread(void *param)
{
/* The worker thread loop. Set up the thread-specific reference to itself and
* start looping. The loop consists of blocking dequeing and handling messages.
@@ -207,7 +207,7 @@ PRIVATE void *worker_thread(void *param)
/*===========================================================================*
* master_create_worker *
*===========================================================================*/
PRIVATE void master_create_worker(worker_t *wp, worker_id_t worker_id,
static void master_create_worker(worker_t *wp, worker_id_t worker_id,
device_id_t device_id)
{
/* Start a new worker thread.
@@ -240,7 +240,7 @@ PRIVATE void master_create_worker(worker_t *wp, worker_id_t worker_id,
/*===========================================================================*
* master_destroy_worker *
*===========================================================================*/
PRIVATE void master_destroy_worker(worker_t *wp)
static void master_destroy_worker(worker_t *wp)
{
/* Clean up resources used by an exited worker thread.
*/
@@ -261,7 +261,7 @@ PRIVATE void master_destroy_worker(worker_t *wp)
/*===========================================================================*
* master_handle_exits *
*===========================================================================*/
PRIVATE void master_handle_exits(void)
static void master_handle_exits(void)
{
/* Destroy the remains of all exited threads.
*/
@@ -276,7 +276,7 @@ PRIVATE void master_handle_exits(void)
/*===========================================================================*
* master_handle_request *
*===========================================================================*/
PRIVATE void master_handle_request(message *m_ptr, int ipc_status)
static void master_handle_request(message *m_ptr, int ipc_status)
{
/* For real request messages, query the device ID, start a thread if none is
* free and the maximum number of threads for that device has not yet been
@@ -337,7 +337,7 @@ PRIVATE void master_handle_request(message *m_ptr, int ipc_status)
/*===========================================================================*
* master_init *
*===========================================================================*/
PRIVATE void master_init(struct blockdriver *bdp)
static void master_init(struct blockdriver *bdp)
{
/* Initialize the state of the master thread.
*/
@@ -371,7 +371,7 @@ PRIVATE void master_init(struct blockdriver *bdp)
/*===========================================================================*
* blockdriver_mt_get_tid *
*===========================================================================*/
PUBLIC thread_id_t blockdriver_mt_get_tid(void)
thread_id_t blockdriver_mt_get_tid(void)
{
/* Return back the ID of this thread.
*/
@@ -388,7 +388,7 @@ PUBLIC thread_id_t blockdriver_mt_get_tid(void)
/*===========================================================================*
* blockdriver_mt_receive *
*===========================================================================*/
PRIVATE void blockdriver_mt_receive(message *m_ptr, int *ipc_status)
static void blockdriver_mt_receive(message *m_ptr, int *ipc_status)
{
/* Receive a message.
*/
@@ -403,7 +403,7 @@ PRIVATE void blockdriver_mt_receive(message *m_ptr, int *ipc_status)
/*===========================================================================*
* blockdriver_mt_task *
*===========================================================================*/
PUBLIC void blockdriver_mt_task(struct blockdriver *driver_tab)
void blockdriver_mt_task(struct blockdriver *driver_tab)
{
/* The multithreaded driver task.
*/
@@ -444,7 +444,7 @@ PUBLIC void blockdriver_mt_task(struct blockdriver *driver_tab)
/*===========================================================================*
* blockdriver_mt_terminate *
*===========================================================================*/
PUBLIC void blockdriver_mt_terminate(void)
void blockdriver_mt_terminate(void)
{
/* Instruct libblockdriver to shut down.
*/
@@ -455,7 +455,7 @@ PUBLIC void blockdriver_mt_terminate(void)
/*===========================================================================*
* blockdriver_mt_sleep *
*===========================================================================*/
PUBLIC void blockdriver_mt_sleep(void)
void blockdriver_mt_sleep(void)
{
/* Let the current thread sleep until it gets woken up by the master thread.
*/
@@ -472,7 +472,7 @@ PUBLIC void blockdriver_mt_sleep(void)
/*===========================================================================*
* blockdriver_mt_wakeup *
*===========================================================================*/
PUBLIC void blockdriver_mt_wakeup(thread_id_t id)
void blockdriver_mt_wakeup(thread_id_t id)
{
/* Wake up a sleeping worker thread from the master thread.
*/
@@ -496,7 +496,7 @@ PUBLIC void blockdriver_mt_wakeup(thread_id_t id)
/*===========================================================================*
* blockdriver_mt_set_workers *
*===========================================================================*/
PUBLIC void blockdriver_mt_set_workers(device_id_t id, int workers)
void blockdriver_mt_set_workers(device_id_t id, int workers)
{
/* Set the number of worker threads for the given device.
*/

12
lib/libblockdriver/driver_st.c
View File

@@ -18,12 +18,12 @@
#include "driver.h"
#include "mq.h"
PRIVATE int running;
static int running;
/*===========================================================================*
* blockdriver_receive_mq *
*===========================================================================*/
PUBLIC int blockdriver_receive_mq(message *m_ptr, int *status_ptr)
int blockdriver_receive_mq(message *m_ptr, int *status_ptr)
{
/* receive() interface for drivers with message queueing. */
@@ -38,7 +38,7 @@ PUBLIC int blockdriver_receive_mq(message *m_ptr, int *status_ptr)
/*===========================================================================*
* blockdriver_terminate *
*===========================================================================*/
PUBLIC void blockdriver_terminate(void)
void blockdriver_terminate(void)
{
/* Break out of the main driver loop after finishing the current request. */
@@ -48,7 +48,7 @@ PUBLIC void blockdriver_terminate(void)
/*===========================================================================*
* blockdriver_task *
*===========================================================================*/
PUBLIC void blockdriver_task(struct blockdriver *bdp)
void blockdriver_task(struct blockdriver *bdp)
{
/* Main program of any block device driver task. */
int r, ipc_status;
@@ -70,7 +70,7 @@ PUBLIC void blockdriver_task(struct blockdriver *bdp)
/*===========================================================================*
* blockdriver_process *
*===========================================================================*/
PUBLIC void blockdriver_process(struct blockdriver *bdp, message *m_ptr,
void blockdriver_process(struct blockdriver *bdp, message *m_ptr,
int ipc_status)
{
/* Handle the given received message. */
@@ -91,7 +91,7 @@ PUBLIC void blockdriver_process(struct blockdriver *bdp, message *m_ptr,
/*===========================================================================*
* blockdriver_mq_queue *
*===========================================================================*/
PUBLIC int blockdriver_mq_queue(message *m, int status)
int blockdriver_mq_queue(message *m, int status)
{
/* Queue a message for later processing. */

18
lib/libblockdriver/drvlib.c
View File

@@ -11,18 +11,18 @@
/* Extended partition? */
#define ext_part(s) ((s) == 0x05 || (s) == 0x0F)
FORWARD void parse_part_table(struct blockdriver *bdp, int device, int
static void parse_part_table(struct blockdriver *bdp, int device, int
style, int atapi, u8_t *tmp_buf);
FORWARD void extpartition(struct blockdriver *bdp, int extdev, unsigned
static void extpartition(struct blockdriver *bdp, int extdev, unsigned
long extbase, u8_t *tmp_buf);
FORWARD int get_part_table(struct blockdriver *bdp, int device, unsigned
static int get_part_table(struct blockdriver *bdp, int device, unsigned
long offset, struct part_entry *table, u8_t *tmp_buf);
FORWARD void sort(struct part_entry *table);
static void sort(struct part_entry *table);
/*============================================================================*
* partition *
*============================================================================*/
PUBLIC void partition(bdp, device, style, atapi)
void partition(bdp, device, style, atapi)
struct blockdriver *bdp; /* device dependent entry points */
int device; /* device to partition */
int style; /* partitioning style: floppy, primary, sub. */
@@ -51,7 +51,7 @@ int atapi; /* atapi device */
/*============================================================================*
* parse_part_table *
*============================================================================*/
PRIVATE void parse_part_table(bdp, device, style, atapi, tmp_buf)
static void parse_part_table(bdp, device, style, atapi, tmp_buf)
struct blockdriver *bdp; /* device dependent entry points */
int device; /* device to partition */
int style; /* partitioning style: floppy, primary, sub. */
@@ -128,7 +128,7 @@ u8_t *tmp_buf; /* temporary buffer */
/*============================================================================*
* extpartition *
*============================================================================*/
PRIVATE void extpartition(bdp, extdev, extbase, tmp_buf)
static void extpartition(bdp, extdev, extbase, tmp_buf)
struct blockdriver *bdp; /* device dependent entry points */
int extdev; /* extended partition to scan */
unsigned long extbase; /* sector offset of the base ext. partition */
@@ -177,7 +177,7 @@ u8_t *tmp_buf; /* temporary buffer */
/*============================================================================*
* get_part_table *
*============================================================================*/
PRIVATE int get_part_table(bdp, device, offset, table, tmp_buf)
static int get_part_table(bdp, device, offset, table, tmp_buf)
struct blockdriver *bdp;
int device;
unsigned long offset; /* sector offset to the table */
@@ -210,7 +210,7 @@ u8_t *tmp_buf; /* temporary buffer */
/*===========================================================================*
* sort *
*===========================================================================*/
PRIVATE void sort(table)
static void sort(table)
struct part_entry *table;
{
/* Sort a partition table. */

12
lib/libblockdriver/mq.c
View File

@@ -21,14 +21,14 @@ struct mq_cell {
STAILQ_ENTRY(mq_cell) next;
};
PRIVATE struct mq_cell pool[MQ_SIZE];
PRIVATE STAILQ_HEAD(queue, mq_cell) queue[MAX_DEVICES];
PRIVATE STAILQ_HEAD(free_list, mq_cell) free_list;
static struct mq_cell pool[MQ_SIZE];
static STAILQ_HEAD(queue, mq_cell) queue[MAX_DEVICES];
static STAILQ_HEAD(free_list, mq_cell) free_list;
/*===========================================================================*
* mq_init *
*===========================================================================*/
PUBLIC void mq_init(void)
void mq_init(void)
{
/* Initialize the message queues and message cells.
*/
@@ -46,7 +46,7 @@ PUBLIC void mq_init(void)
/*===========================================================================*
* mq_enqueue *
*===========================================================================*/
PUBLIC int mq_enqueue(device_id_t device_id, const message *mess,
int mq_enqueue(device_id_t device_id, const message *mess,
int ipc_status)
{
/* Add a message, including its IPC status, to the message queue of a device.
@@ -73,7 +73,7 @@ PUBLIC int mq_enqueue(device_id_t device_id, const message *mess,
/*===========================================================================*
* mq_dequeue *
*===========================================================================*/
PUBLIC int mq_dequeue(device_id_t device_id, message *mess, int *ipc_status)
int mq_dequeue(device_id_t device_id, message *mess, int *ipc_status)
{
/* Return and remove a message, including its IPC status, from the message
* queue of a thread. Return TRUE iff a message was available.

26
lib/libblockdriver/trace.c
View File

@@ -13,24 +13,24 @@
#define NO_TRACEDEV ((dev_t) -1)
#define NO_TIME ((u32_t) -1)
PRIVATE int trace_enabled = FALSE;
PRIVATE dev_t trace_dev = NO_TRACEDEV;
PRIVATE btrace_entry *trace_buf = NULL;
PRIVATE size_t trace_size = 0;
PRIVATE size_t trace_pos;
PRIVATE size_t trace_next;
PRIVATE u64_t trace_tsc;
static int trace_enabled = FALSE;
static dev_t trace_dev = NO_TRACEDEV;
static btrace_entry *trace_buf = NULL;
static size_t trace_size = 0;
static size_t trace_pos;
static size_t trace_next;
static u64_t trace_tsc;
/* Pointers to in-progress trace entries for each thread (all worker threads,
* plus one for the main thread). Each pointer is set to NULL whenever no
* operation is currently being traced for that thread, for whatever reason.
*/
PRIVATE btrace_entry *trace_ptr[MAX_THREADS + 1] = { NULL };
static btrace_entry *trace_ptr[MAX_THREADS + 1] = { NULL };
/*===========================================================================*
* trace_gettime *
*===========================================================================*/
PRIVATE u32_t trace_gettime(void)
static u32_t trace_gettime(void)
{
/* Return the current time, in microseconds since the start of the trace.
*/
@@ -48,7 +48,7 @@ PRIVATE u32_t trace_gettime(void)
/*===========================================================================*
* trace_ctl *
*===========================================================================*/
PUBLIC int trace_ctl(dev_t minor, unsigned int request, endpoint_t endpt,
int trace_ctl(dev_t minor, unsigned int request, endpoint_t endpt,
cp_grant_id_t grant)
{
/* Process a block trace control request.
@@ -164,7 +164,7 @@ PUBLIC int trace_ctl(dev_t minor, unsigned int request, endpoint_t endpt,
/*===========================================================================*
* trace_start *
*===========================================================================*/
PUBLIC void trace_start(thread_id_t id, message *m_ptr)
void trace_start(thread_id_t id, message *m_ptr)
{
/* Start creating a trace entry.
*/
@@ -247,7 +247,7 @@ PUBLIC void trace_start(thread_id_t id, message *m_ptr)
/*===========================================================================*
* trace_setsize *
*===========================================================================*/
PUBLIC void trace_setsize(thread_id_t id, size_t size)
void trace_setsize(thread_id_t id, size_t size)
{
/* Set the current trace entry's actual (byte) size, for vector requests.
*/
@@ -265,7 +265,7 @@ PUBLIC void trace_setsize(thread_id_t id, size_t size)
/*===========================================================================*
* trace_finish *
*===========================================================================*/
PUBLIC void trace_finish(thread_id_t id, int result)
void trace_finish(thread_id_t id, int result)
{
/* Finish a trace entry.
*/

4
lib/libc/gen/minix/sysconf.c
View File

@@ -19,7 +19,7 @@
__weak_alias(sysconf, __sysconf)
#endif
PRIVATE u32_t get_hz(void)
static u32_t get_hz(void)
{
FILE *fp;
u32_t hz;
@@ -38,7 +38,7 @@ PRIVATE u32_t get_hz(void)
return DEFAULT_HZ;
}
PUBLIC long int sysconf(name)
long int sysconf(name)
int name; /* property being inspected */
{
switch(name) {

2
lib/libc/gen/minix/times.c
View File

@@ -8,7 +8,7 @@
__weak_alias(times, _times)
#endif
PUBLIC clock_t times(buf)
clock_t times(buf)
struct tms *buf;
{
message m;

2
lib/libc/gen/minix/utime.c
View File

@@ -7,7 +7,7 @@
#include <string.h>
#include <utime.h>
PUBLIC int utime(const char *name, const struct utimbuf *timp)
int utime(const char *name, const struct utimbuf *timp)
{
message m;

4
lib/libc/sys-minix/_mcontext.c
View File

@@ -8,7 +8,7 @@
#include <ucontext.h>
#include <unistd.h>
PUBLIC int setmcontext(const mcontext_t *mcp)
int setmcontext(const mcontext_t *mcp)
{
message m;
@@ -18,7 +18,7 @@ PUBLIC int setmcontext(const mcontext_t *mcp)
}
PUBLIC int getmcontext(mcontext_t *mcp)
int getmcontext(mcontext_t *mcp)
{
message m;

10
lib/libc/sys-minix/_ucontext.c
View File

@@ -15,7 +15,7 @@ void ctx_start(void (*)(void), int, ...);
/*===========================================================================*
* setuctx *
*===========================================================================*/
PUBLIC int setuctx(const ucontext_t *ucp)
int setuctx(const ucontext_t *ucp)
{
int r;
@@ -42,7 +42,7 @@ PUBLIC int setuctx(const ucontext_t *ucp)
/*===========================================================================*
* getuctx *
*===========================================================================*/
PUBLIC int getuctx(ucontext_t *ucp)
int getuctx(ucontext_t *ucp)
{
int r;
@@ -69,7 +69,7 @@ PUBLIC int getuctx(ucontext_t *ucp)
/*===========================================================================*
* makecontext *
*===========================================================================*/
PUBLIC void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
{
va_list ap;
unsigned int *stack_top;
@@ -157,7 +157,7 @@ PUBLIC void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
/*===========================================================================*
* swapcontext *
*===========================================================================*/
PUBLIC int swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
int swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
{
int r;
@@ -186,7 +186,7 @@ PUBLIC int swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
/*===========================================================================*
* resumecontext *
*===========================================================================*/
PUBLIC void resumecontext(ucontext_t *ucp)
void resumecontext(ucontext_t *ucp)
{
if (ucp->uc_link == NULL) exit(0);

2
lib/libc/sys-minix/access.c
View File

@@ -8,7 +8,7 @@
__weak_alias(access, _access)
#endif
PUBLIC int access(name, mode)
int access(name, mode)
_CONST char *name;
int mode;
{

2
lib/libc/sys-minix/brk.c
View File

@@ -19,7 +19,7 @@ extern char *_brksize;
* as with system calls. In this way, if a user inadvertently defines a
* procedure brk, MINIX may continue to work because the true call is _brk.
*/
PUBLIC int brk(addr)
int brk(addr)
void *addr;
{
message m;

4
lib/libc/sys-minix/chdir.c
View File

@@ -9,7 +9,7 @@ __weak_alias(chdir, _chdir)
__weak_alias(fchdir, _fchdir)
#endif
PUBLIC int chdir(name)
int chdir(name)
_CONST char *name;
{
message m;
@@ -18,7 +18,7 @@ _CONST char *name;
return(_syscall(VFS_PROC_NR, CHDIR, &m));
}
PUBLIC int fchdir(fd)
int fchdir(fd)
int fd;
{
message m;

2
lib/libc/sys-minix/chmod.c
View File

@@ -8,7 +8,7 @@
__weak_alias(chmod, _chmod)
#endif
PUBLIC int chmod(const char *name, mode_t mode)
int chmod(const char *name, mode_t mode)
{
message m;

2
lib/libc/sys-minix/chown.c
View File

@@ -9,7 +9,7 @@
__weak_alias(chown, _chown)
#endif
PUBLIC int chown(const char *name, uid_t owner, gid_t grp)
int chown(const char *name, uid_t owner, gid_t grp)
{
message m;

2
lib/libc/sys-minix/chroot.c
View File

@@ -8,7 +8,7 @@
__weak_alias(chroot, _chroot)
#endif
PUBLIC int chroot(name)
int chroot(name)
_CONST char *name;
{
message m;

2
lib/libc/sys-minix/close.c
View File

@@ -8,7 +8,7 @@
__weak_alias(close, _close)
#endif
PUBLIC int close(fd)
int close(fd)
int fd;
{
message m;

2
lib/libc/sys-minix/dup.c
View File

@@ -9,7 +9,7 @@
__weak_alias(dup, _dup)
#endif
PUBLIC int dup(fd)
int dup(fd)
int fd;
{
return(fcntl(fd, F_DUPFD, 0));

2
lib/libc/sys-minix/dup2.c
View File

@@ -9,7 +9,7 @@
__weak_alias(dup2, _dup2)
#endif
PUBLIC int dup2(fd, fd2)
int dup2(fd, fd2)
int fd, fd2;
{
/* The behavior of dup2 is defined by POSIX in 6.2.1.2 as almost, but not

2
lib/libc/sys-minix/fchmod.c
View File

@@ -8,7 +8,7 @@
__weak_alias(fchmod, _fchmod)
#endif
PUBLIC int fchmod(int fd, mode_t mode)
int fchmod(int fd, mode_t mode)
{
message m;

2
lib/libc/sys-minix/fchown.c
View File

@@ -9,7 +9,7 @@
__weak_alias(fchown, _fchown)
#endif
PUBLIC int fchown(int fd, uid_t owner, gid_t grp)
int fchown(int fd, uid_t owner, gid_t grp)
{
message m;

4
lib/libc/sys-minix/fcntl.c
View File

@@ -10,9 +10,9 @@ __weak_alias(fcntl, _fcntl)
#endif
#if _ANSI
PUBLIC int fcntl(int fd, int cmd, ...)
int fcntl(int fd, int cmd, ...)
#else
PUBLIC int fcntl(fd, cmd)
int fcntl(fd, cmd)
int fd;
int cmd;
#endif

2
lib/libc/sys-minix/fork.c
View File

@@ -8,7 +8,7 @@
__weak_alias(fork, _fork)
#endif
PUBLIC pid_t fork()
pid_t fork()
{
message m;

2
lib/libc/sys-minix/fpathconf.c
View File

@@ -14,7 +14,7 @@
__weak_alias(fpathconf, _fpathconf)
#endif
PUBLIC long fpathconf(fd, name)
long fpathconf(fd, name)
int fd; /* file descriptor being interrogated */
int name; /* property being inspected */
{

2
lib/libc/sys-minix/fsync.c
View File

@@ -8,7 +8,7 @@
__weak_alias(fsync, _fsync)
#endif
PUBLIC int fsync(int fd)
int fsync(int fd)
{
message m;

2
lib/libc/sys-minix/getdents.c
View File

@@ -4,7 +4,7 @@
#include <dirent.h>
PUBLIC ssize_t getdents(fd, buffer, nbytes)
ssize_t getdents(fd, buffer, nbytes)
int fd;
char *buffer;
size_t nbytes;

2
lib/libc/sys-minix/getegid.c
View File

@@ -8,7 +8,7 @@
__weak_alias(getegid, _getegid)
#endif
PUBLIC gid_t getegid()
gid_t getegid()
{
message m;

2
lib/libc/sys-minix/geteuid.c
View File

@@ -8,7 +8,7 @@
__weak_alias(geteuid, _geteuid)
#endif
PUBLIC uid_t geteuid()
uid_t geteuid()
{
message m;

2
lib/libc/sys-minix/getgid.c
View File

@@ -8,7 +8,7 @@
__weak_alias(getgid, _getgid)
#endif
PUBLIC gid_t getgid()
gid_t getgid()
{
message m;

2
lib/libc/sys-minix/getgroups.c
View File

@@ -13,7 +13,7 @@ __weak_alias(getgroups, _getgroups)
#endif
PUBLIC int getgroups(int ngroups, gid_t *arr)
int getgroups(int ngroups, gid_t *arr)
{
message m;
m.m1_i1 = ngroups;

2
lib/libc/sys-minix/getpgrp.c
View File

@@ -8,7 +8,7 @@
__weak_alias(getpgrp, _getpgrp)
#endif
PUBLIC pid_t getpgrp()
pid_t getpgrp()
{
message m;

2
lib/libc/sys-minix/getpid.c
View File

@@ -8,7 +8,7 @@
__weak_alias(getpid, _getpid)
#endif
PUBLIC pid_t getpid()
pid_t getpid()
{
message m;

2
lib/libc/sys-minix/getppid.c
View File

@@ -8,7 +8,7 @@
__weak_alias(getppid, _getppid)
#endif
PUBLIC pid_t getppid()
pid_t getppid()
{
message m;

2
lib/libc/sys-minix/getuid.c
View File

@@ -8,7 +8,7 @@
__weak_alias(getuid, _getuid)
#endif
PUBLIC uid_t getuid()
uid_t getuid()
{
message m;

2
lib/libc/sys-minix/ioctl.c
View File

@@ -8,7 +8,7 @@
__weak_alias(ioctl, _ioctl)
#endif
PUBLIC int ioctl(fd, request, data)
int ioctl(fd, request, data)
int fd;
int request;
void *data;

2
lib/libc/sys-minix/kill.c
View File

@@ -8,7 +8,7 @@
__weak_alias(kill, _kill)
#endif
PUBLIC int kill(proc, sig)
int kill(proc, sig)
int proc; /* which process is to be sent the signal */
int sig; /* signal number */
{

2
lib/libc/sys-minix/link.c
View File

@@ -9,7 +9,7 @@
__weak_alias(link, _link)
#endif
PUBLIC int link(const char *name, const char *name2)
int link(const char *name, const char *name2)
{
message m;

2
lib/libc/sys-minix/lseek.c
View File

@@ -8,7 +8,7 @@
__weak_alias(lseek, _lseek)
#endif
PUBLIC off_t lseek(fd, offset, whence)
off_t lseek(fd, offset, whence)
int fd;
off_t offset;
int whence;

2
lib/libc/sys-minix/lseek64.c
View File

@@ -5,7 +5,7 @@
#include <unistd.h>
#include <minix/u64.h>
PUBLIC int lseek64(fd, offset, whence, newpos)
int lseek64(fd, offset, whence, newpos)
int fd;
u64_t offset;
int whence;

2
lib/libc/sys-minix/m_closefrom.c
View File

@@ -4,7 +4,7 @@
#include <stdlib.h>
#include <unistd.h>
PUBLIC int closefrom(int fd)
int closefrom(int fd)
{
int f, ok = 0, e = 0;
for(f = fd; f < __MINIX_OPEN_MAX; f++) {

2
lib/libc/sys-minix/mkdir.c
View File

@@ -9,7 +9,7 @@
__weak_alias(mkdir, _mkdir)
#endif
PUBLIC int mkdir(const char *name, mode_t mode)
int mkdir(const char *name, mode_t mode)
{
message m;

2
lib/libc/sys-minix/mkfifo.c
View File

@@ -9,7 +9,7 @@
__weak_alias(mkfifo, _mkfifo)
#endif
PUBLIC int mkfifo(const char *name, mode_t mode)
int mkfifo(const char *name, mode_t mode)
{
return mknod(name, mode | S_IFIFO, (dev_t) 0);
}

2
lib/libc/sys-minix/mknod.c
View File

@@ -7,7 +7,7 @@
#include <unistd.h>
#include <sys/stat.h>
PUBLIC int mknod(const char *name, mode_t mode, dev_t dev)
int mknod(const char *name, mode_t mode, dev_t dev)
{
message m;

16
lib/libc/sys-minix/mmap.c
View File

@@ -21,7 +21,7 @@ __weak_alias(minix_munmap_text, _minix_munmap_text)
#include <string.h>
#include <errno.h>
PUBLIC void *minix_mmap(void *addr, size_t len, int prot, int flags,
void *minix_mmap(void *addr, size_t len, int prot, int flags,
int fd, off_t offset)
{
message m;
@@ -43,7 +43,7 @@ PUBLIC void *minix_mmap(void *addr, size_t len, int prot, int flags,
return (void *) m.VMM_RETADDR;
}
PUBLIC int minix_munmap(void *addr, size_t len)
int minix_munmap(void *addr, size_t len)
{
message m;
@@ -54,7 +54,7 @@ PUBLIC int minix_munmap(void *addr, size_t len)
}
PUBLIC int minix_munmap_text(void *addr, size_t len)
int minix_munmap_text(void *addr, size_t len)
{
message m;
@@ -64,7 +64,7 @@ PUBLIC int minix_munmap_text(void *addr, size_t len)
return _syscall(VM_PROC_NR, VM_MUNMAP_TEXT, &m);
}
PUBLIC void *vm_remap(endpoint_t d,
void *vm_remap(endpoint_t d,
endpoint_t s,
void *da,
void *sa,
@@ -85,7 +85,7 @@ PUBLIC void *vm_remap(endpoint_t d,
return (void *) m.VMRE_RETA;
}
PUBLIC void *vm_remap_ro(endpoint_t d,
void *vm_remap_ro(endpoint_t d,
endpoint_t s,
void *da,
void *sa,
@@ -106,7 +106,7 @@ PUBLIC void *vm_remap_ro(endpoint_t d,
return (void *) m.VMRE_RETA;
}
PUBLIC int vm_unmap(endpoint_t endpt, void *addr)
int vm_unmap(endpoint_t endpt, void *addr)
{
message m;
@@ -116,7 +116,7 @@ PUBLIC int vm_unmap(endpoint_t endpt, void *addr)
return _syscall(VM_PROC_NR, VM_SHM_UNMAP, &m);
}
PUBLIC unsigned long vm_getphys(int endpt, void *addr)
unsigned long vm_getphys(int endpt, void *addr)
{
message m;
int r;
@@ -130,7 +130,7 @@ PUBLIC unsigned long vm_getphys(int endpt, void *addr)
return m.VMPHYS_RETA;
}
PUBLIC u8_t vm_getrefcount(endpoint_t endpt, void *addr)
u8_t vm_getrefcount(endpoint_t endpt, void *addr)
{
message m;
int r;

8
lib/libc/sys-minix/mount.c
View File

@@ -23,7 +23,7 @@ __weak_alias(umount2, _umount2)
static char fspath[] = "/sbin/:/usr/pkg/bin/"; /* Must include trailing '/' */
PRIVATE int rs_down(char *label)
static int rs_down(char *label)
{
char cmd[200];
if(strlen(_PATH_SERVICE)+strlen(label)+50 >= sizeof(cmd))
@@ -32,7 +32,7 @@ PRIVATE int rs_down(char *label)
return system(cmd);
}
PUBLIC int mount(special, name, mountflags, type, args)
int mount(special, name, mountflags, type, args)
char *name, *special, *type, *args;
int mountflags;
{
@@ -163,13 +163,13 @@ int mountflags;
return r;
}
PUBLIC int umount(name)
int umount(name)
_CONST char *name;
{
return umount2(name, 0);
}
PUBLIC int umount2(name, flags)
int umount2(name, flags)
_CONST char *name;
int flags;
{

4
lib/libc/sys-minix/open.c
View File

@@ -11,9 +11,9 @@ __weak_alias(open, _open)
#endif
#if _ANSI
PUBLIC int open(const char *name, int flags, ...)
int open(const char *name, int flags, ...)
#else
PUBLIC int open(const char *name, int flags)
int open(const char *name, int flags)
#endif
{
va_list argp;

2
lib/libc/sys-minix/pathconf.c
View File

@@ -12,7 +12,7 @@
__weak_alias(pathconf, _pathconf)
#endif
PUBLIC long pathconf(path, name)
long pathconf(path, name)
_CONST char *path; /* name of file being interrogated */
int name; /* property being inspected */
{

2
lib/libc/sys-minix/sbrk.c
View File

@@ -10,7 +10,7 @@ __weak_alias(sbrk, _sbrk)
extern char *_brksize;
PUBLIC void *sbrk(incr)
void *sbrk(incr)
intptr_t incr;
{
char *newsize, *oldsize;

2
lib/libc/sys-minix/vfork.c
View File

@@ -8,7 +8,7 @@
__weak_alias(vfork, _vfork)
#endif
PUBLIC pid_t vfork()
pid_t vfork()
{
message m;

44
lib/libchardriver/chardriver.c
View File

@@ -40,16 +40,16 @@
#include <minix/chardriver.h>
#include <minix/ds.h>
PRIVATE int running;
static int running;
/* Management data for opened devices. */
PRIVATE int open_devs[MAX_NR_OPEN_DEVICES];
PRIVATE int next_open_devs_slot = 0;
static int open_devs[MAX_NR_OPEN_DEVICES];
static int next_open_devs_slot = 0;
/*===========================================================================*
* clear_open_devs *
*===========================================================================*/
PRIVATE void clear_open_devs(void)
static void clear_open_devs(void)
{
/* Reset the set of previously opened minor devices. */
next_open_devs_slot = 0;
@@ -58,7 +58,7 @@ PRIVATE void clear_open_devs(void)
/*===========================================================================*
* is_open_dev *
*===========================================================================*/
PRIVATE int is_open_dev(int device)
static int is_open_dev(int device)
{
/* Check whether the given minor device has previously been opened. */
int i;
@@ -73,7 +73,7 @@ PRIVATE int is_open_dev(int device)
/*===========================================================================*
* set_open_dev *
*===========================================================================*/
PRIVATE void set_open_dev(int device)
static void set_open_dev(int device)
{
/* Mark the given minor device as having been opened. */
@@ -87,7 +87,7 @@ PRIVATE void set_open_dev(int device)
/*===========================================================================*
* chardriver_announce *
*===========================================================================*/
PUBLIC void chardriver_announce(void)
void chardriver_announce(void)
{
/* Announce we are up after a fresh start or restart. */
int r;
@@ -119,7 +119,7 @@ PUBLIC void chardriver_announce(void)
/*===========================================================================*
* async_reply *
*===========================================================================*/
PRIVATE void async_reply(message *mess, int r)
static void async_reply(message *mess, int r)
{
/* Send a reply using the asynchronous character device protocol. */
message reply_mess;
@@ -185,7 +185,7 @@ PRIVATE void async_reply(message *mess, int r)
/*===========================================================================*
* sync_reply *
*===========================================================================*/
PRIVATE void sync_reply(message *m_ptr, int ipc_status, int reply)
static void sync_reply(message *m_ptr, int ipc_status, int reply)
{
/* Reply to a message sent to the driver. */
endpoint_t caller_e, user_e;
@@ -211,7 +211,7 @@ PRIVATE void sync_reply(message *m_ptr, int ipc_status, int reply)
/*===========================================================================*
* send_reply *
*===========================================================================*/
PRIVATE void send_reply(int type, message *m_ptr, int ipc_status, int reply)
static void send_reply(int type, message *m_ptr, int ipc_status, int reply)
{
/* Prepare and send a reply message. */
@@ -227,7 +227,7 @@ PRIVATE void send_reply(int type, message *m_ptr, int ipc_status, int reply)
/*===========================================================================*
* do_rdwt *
*===========================================================================*/
PRIVATE int do_rdwt(struct chardriver *cdp, message *mp)
static int do_rdwt(struct chardriver *cdp, message *mp)
{
/* Carry out a single read or write request. */
iovec_t iovec1;
@@ -261,7 +261,7 @@ PRIVATE int do_rdwt(struct chardriver *cdp, message *mp)
/*===========================================================================*
* do_vrdwt *
*===========================================================================*/
PRIVATE int do_vrdwt(struct chardriver *cdp, message *mp)
static int do_vrdwt(struct chardriver *cdp, message *mp)
{
/* Carry out an device read or write to/from a vector of user addresses.
* The "user addresses" are assumed to be safe, i.e. FS transferring to/from
@@ -307,7 +307,7 @@ PRIVATE int do_vrdwt(struct chardriver *cdp, message *mp)
/*===========================================================================*
* handle_notify *
*===========================================================================*/
PRIVATE void handle_notify(struct chardriver *cdp, message *m_ptr)
static void handle_notify(struct chardriver *cdp, message *m_ptr)
{
/* Take care of the notifications (interrupt and clock messages) by calling the
* appropiate callback functions. Never send a reply.
@@ -329,7 +329,7 @@ PRIVATE void handle_notify(struct chardriver *cdp, message *m_ptr)
/*===========================================================================*
* handle_request *
*===========================================================================*/
PRIVATE int handle_request(struct chardriver *cdp, message *m_ptr)
static int handle_request(struct chardriver *cdp, message *m_ptr)
{
/* Call the appropiate driver function, based on the type of request. Return
* the result code that is to be sent back to the caller, or EDONTREPLY if no
@@ -378,7 +378,7 @@ PRIVATE int handle_request(struct chardriver *cdp, message *m_ptr)
/*===========================================================================*
* chardriver_process *
*===========================================================================*/
PUBLIC void chardriver_process(struct chardriver *cdp, int driver_type,
void chardriver_process(struct chardriver *cdp, int driver_type,
message *m_ptr, int ipc_status)
{
/* Handle the given received message. */
@@ -399,7 +399,7 @@ PUBLIC void chardriver_process(struct chardriver *cdp, int driver_type,
/*===========================================================================*
* chardriver_task *
*===========================================================================*/
PUBLIC void chardriver_task(struct chardriver *cdp, int driver_type)
void chardriver_task(struct chardriver *cdp, int driver_type)
{
/* Main program of any device driver task. */
int r, ipc_status;
@@ -421,7 +421,7 @@ PUBLIC void chardriver_task(struct chardriver *cdp, int driver_type)
/*===========================================================================*
* do_nop *
*===========================================================================*/
PUBLIC int do_nop(message *UNUSED(mp))
int do_nop(message *UNUSED(mp))
{
return(OK);
}
@@ -429,7 +429,7 @@ PUBLIC int do_nop(message *UNUSED(mp))
/*===========================================================================*
* nop_ioctl *
*===========================================================================*/
PUBLIC int nop_ioctl(message *UNUSED(mp))
int nop_ioctl(message *UNUSED(mp))
{
return(ENOTTY);
}
@@ -437,7 +437,7 @@ PUBLIC int nop_ioctl(message *UNUSED(mp))
/*===========================================================================*
* nop_alarm *
*===========================================================================*/
PUBLIC void nop_alarm(message *UNUSED(mp))
void nop_alarm(message *UNUSED(mp))
{
/* Ignore the leftover alarm. */
}
@@ -445,7 +445,7 @@ PUBLIC void nop_alarm(message *UNUSED(mp))
/*===========================================================================*
* nop_cleanup *
*===========================================================================*/
PUBLIC void nop_cleanup(void)
void nop_cleanup(void)
{
/* Nothing to clean up. */
}
@@ -453,7 +453,7 @@ PUBLIC void nop_cleanup(void)
/*===========================================================================*
* nop_cancel *
*===========================================================================*/
PUBLIC int nop_cancel(message *UNUSED(m))
int nop_cancel(message *UNUSED(m))
{
/* Nothing to do for cancel. */
return(OK);
@@ -462,7 +462,7 @@ PUBLIC int nop_cancel(message *UNUSED(m))
/*===========================================================================*
* nop_select *
*===========================================================================*/
PUBLIC int nop_select(message *UNUSED(m))
int nop_select(message *UNUSED(m))
{
/* Nothing to do for select. */
return(OK);

4
lib/libcompat_minix/mtab.c
View File

@@ -56,7 +56,7 @@ int get_mtab_entry(char *special, char *mounted_on, char *version, char
*rw_flag);
int put_mtab_entry(char *special, char *mounted_on, char *version, char
*rw_flag);
PRIVATE void err(char *prog_name, char *str );
static void err(char *prog_name, char *str );
int load_mtab(prog_name)
@@ -195,7 +195,7 @@ char *rw_flag;
}
PRIVATE void
static void
err(prog_name, str)
char *prog_name, *str;
{

10
lib/libddekit/src/condvar.c
View File

@@ -20,7 +20,7 @@ struct ddekit_condvar {
/*****************************************************************************/
/* ddekit_condvar_init */
/*****************************************************************************/
PUBLIC ddekit_condvar_t * ddekit_condvar_init(void) {
ddekit_condvar_t * ddekit_condvar_init(void) {
ddekit_condvar_t *cv;
cv = (ddekit_condvar_t *) ddekit_simple_malloc(sizeof(ddekit_condvar_t));
DDEBUG_MSG_VERBOSE("cv: %p", cv);
@@ -30,7 +30,7 @@ PUBLIC ddekit_condvar_t * ddekit_condvar_init(void) {
/*****************************************************************************/
/* ddekit_condvar_deinit */
/*****************************************************************************/
PUBLIC void ddekit_condvar_deinit(ddekit_condvar_t *cvp) {
void ddekit_condvar_deinit(ddekit_condvar_t *cvp) {
DDEBUG_MSG_VERBOSE("cv: %p", cvp);
ddekit_simple_free(cvp);
}
@@ -38,7 +38,7 @@ PUBLIC void ddekit_condvar_deinit(ddekit_condvar_t *cvp) {
/*****************************************************************************/
/* ddekit_condvar_wait */
/*****************************************************************************/
PUBLIC void ddekit_condvar_wait(ddekit_condvar_t *cv, ddekit_lock_t *mp) {
void ddekit_condvar_wait(ddekit_condvar_t *cv, ddekit_lock_t *mp) {
DDEBUG_MSG_VERBOSE("wait cv: %p, thread id: %d, name: %s",
cv, ddekit_thread_myself()->id, ddekit_thread_myself()->name);
@@ -65,7 +65,7 @@ PUBLIC void ddekit_condvar_wait(ddekit_condvar_t *cv, ddekit_lock_t *mp) {
/*****************************************************************************/
/* ddekit_condvar_wait_timed */
/*****************************************************************************/
PUBLIC int ddekit_condvar_wait_timed
int ddekit_condvar_wait_timed
(ddekit_condvar_t *cvp, ddekit_lock_t *mp, int timo)
{
/*
@@ -79,7 +79,7 @@ PUBLIC int ddekit_condvar_wait_timed
/*****************************************************************************/
/* ddekit_condvar_signal */
/*****************************************************************************/
PUBLIC void ddekit_condvar_signal(ddekit_condvar_t *cv)
void ddekit_condvar_signal(ddekit_condvar_t *cv)
{
DDEBUG_MSG_VERBOSE("cv: %p", cv);

10
lib/libddekit/src/dde.c
View File

@@ -22,13 +22,13 @@ void ddekit_pgtab_init(void);
static ddekit_thread_t *dispatch_th = 0;
FORWARD void dispatcher_thread(void * unused);
FORWARD void ddekit_dispatcher_thread_init(void);
static void dispatcher_thread(void * unused);
static void ddekit_dispatcher_thread_init(void);
/****************************************************************************/
/* dispatcher_thread */
/****************************************************************************/
PRIVATE void dispatcher_thread(void *unused) {
static void dispatcher_thread(void *unused) {
/*
* Gets all messages and dispatches them.
@@ -92,7 +92,7 @@ PRIVATE void dispatcher_thread(void *unused) {
/****************************************************************************/
/* ddekit_dispatcher_thread_init */
/****************************************************************************/
PRIVATE void ddekit_dispatcher_thread_init()
static void ddekit_dispatcher_thread_init()
{
dispatch_th = ddekit_thread_create(dispatcher_thread, NULL, "dispatch");
@@ -103,7 +103,7 @@ PRIVATE void ddekit_dispatcher_thread_init()
/****************************************************************************/
/* ddekit_init */
/****************************************************************************/
PUBLIC void ddekit_init(void)
void ddekit_init(void)
{
sef_startup();

4
lib/libddekit/src/initcall.c
View File

@@ -15,7 +15,7 @@ static struct __ddekit_initcall_s head = {0,0,0};
/****************************************************************************/
/* __ddekit_add_initcall */
/****************************************************************************/
PUBLIC void __attribute__((used))
void __attribute__((used))
__ddekit_add_initcall(struct __ddekit_initcall_s * ic) {
/* This function is required for the DDEKIT_INITCALL makro */
@@ -42,7 +42,7 @@ __ddekit_add_initcall(struct __ddekit_initcall_s * ic) {
/****************************************************************************/
/* ddekit_do_initcalls */
/****************************************************************************/
PUBLIC void ddekit_do_initcalls()
void ddekit_do_initcalls()
{
struct __ddekit_initcall_s *i = 0;

22
lib/libddekit/src/irq.c
View File

@@ -32,16 +32,16 @@ static ddekit_lock_t lock;
*****************************************************************************/
FORWARD void ddekit_irq_lock(void);
FORWARD void ddekit_irq_unlock(void);
FORWARD struct ddekit_irq_s* find_by_irq(int irq);
FORWARD void ddekit_irq_remove(struct ddekit_irq_s *irq_s);
FORWARD void ddekit_irq_thread(void *data);
static void ddekit_irq_lock(void);
static void ddekit_irq_unlock(void);
static struct ddekit_irq_s* find_by_irq(int irq);
static void ddekit_irq_remove(struct ddekit_irq_s *irq_s);
static void ddekit_irq_thread(void *data);
/******************************************************************************
* ddekit_irq_lock *
*****************************************************************************/
PRIVATE void ddekit_irq_lock(void)
static void ddekit_irq_lock(void)
{
ddekit_lock_lock(&lock);
}
@@ -49,7 +49,7 @@ PRIVATE void ddekit_irq_lock(void)
/******************************************************************************
* ddekit_irq_unlock *
*****************************************************************************/
PRIVATE void ddekit_irq_unlock(void)
static void ddekit_irq_unlock(void)
{
ddekit_lock_unlock(&lock);
}
@@ -57,7 +57,7 @@ PRIVATE void ddekit_irq_unlock(void)
/******************************************************************************
* find_by_irq *
*****************************************************************************/
PRIVATE struct ddekit_irq_s * find_by_irq(int irq)
static struct ddekit_irq_s * find_by_irq(int irq)
{
struct ddekit_irq_s * irq_s;
ddekit_irq_lock();
@@ -80,7 +80,7 @@ PRIVATE struct ddekit_irq_s * find_by_irq(int irq)
/******************************************************************************
* ddekit_irq_remove *
*****************************************************************************/
PRIVATE void ddekit_irq_remove(struct ddekit_irq_s *irq_s)
static void ddekit_irq_remove(struct ddekit_irq_s *irq_s)
{
struct ddekit_irq_s *i;
@@ -114,7 +114,7 @@ PRIVATE void ddekit_irq_remove(struct ddekit_irq_s *irq_s)
/******************************************************************************
* ddekit_irq_thread *
*****************************************************************************/
PRIVATE void ddekit_irq_thread(void *data)
static void ddekit_irq_thread(void *data)
{
/* For each IRQ line an own thread is started */
@@ -239,7 +239,7 @@ void ddekit_init_irqs()
/******************************************************************************
* _ddekit_interrupt_trigger *
*****************************************************************************/
PUBLIC void _ddekit_interrupt_trigger(int irq)
void _ddekit_interrupt_trigger(int irq)
{
struct ddekit_irq_s *irq_s;

14
lib/libddekit/src/lock.c
View File

@@ -21,7 +21,7 @@ struct ddekit_lock {
/******************************************************************************
* ddekit_lock_init_locked *
*****************************************************************************/
PUBLIC void ddekit_lock_init_locked(ddekit_lock_t *mtx)
void ddekit_lock_init_locked(ddekit_lock_t *mtx)
{
(*mtx) = (struct ddekit_lock *)
ddekit_simple_malloc(sizeof(struct ddekit_lock));
@@ -33,7 +33,7 @@ PUBLIC void ddekit_lock_init_locked(ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_init_unlocked *
*****************************************************************************/
PUBLIC void ddekit_lock_init_unlocked(ddekit_lock_t *mtx)
void ddekit_lock_init_unlocked(ddekit_lock_t *mtx)
{
(*mtx) = (struct ddekit_lock *)
ddekit_simple_malloc(sizeof(struct ddekit_lock));
@@ -44,7 +44,7 @@ PUBLIC void ddekit_lock_init_unlocked(ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_deinit *
*****************************************************************************/
PUBLIC void ddekit_lock_deinit (ddekit_lock_t *mtx)
void ddekit_lock_deinit (ddekit_lock_t *mtx)
{
ddekit_simple_free(*mtx);
}
@@ -52,7 +52,7 @@ PUBLIC void ddekit_lock_deinit (ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_lock *
*****************************************************************************/
PUBLIC void ddekit_lock_lock (ddekit_lock_t *mtx)
void ddekit_lock_lock (ddekit_lock_t *mtx)
{
if ((*mtx)->owner == NULL) {
(*mtx)->owner = ddekit_thread_myself();
@@ -84,7 +84,7 @@ PUBLIC void ddekit_lock_lock (ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_try_lock *
*****************************************************************************/
PUBLIC int ddekit_lock_try_lock(ddekit_lock_t *mtx)
int ddekit_lock_try_lock(ddekit_lock_t *mtx)
{
if ((*mtx)->owner == NULL) {
(*mtx)->owner = ddekit_thread_myself();
@@ -97,7 +97,7 @@ PUBLIC int ddekit_lock_try_lock(ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_unlock *
*****************************************************************************/
PUBLIC void ddekit_lock_unlock (ddekit_lock_t *mtx) {
void ddekit_lock_unlock (ddekit_lock_t *mtx) {
ddekit_assert((*mtx)->owner != NULL);
(*mtx)->owner = NULL;
if((*mtx)->wait_queue) {
@@ -112,7 +112,7 @@ PUBLIC void ddekit_lock_unlock (ddekit_lock_t *mtx) {
/******************************************************************************
* ddekit_lock_owner *
*****************************************************************************/
PUBLIC int ddekit_lock_owner(ddekit_lock_t *mtx) {
int ddekit_lock_owner(ddekit_lock_t *mtx) {
return ddekit_thread_get_id((*mtx)->owner);
}

52
lib/libddekit/src/mem.c
View File

@@ -38,22 +38,22 @@ struct ddekit_slab {
struct ddekit_slab_slab empty;
};
FORWARD void ddekit_slab_lock(struct ddekit_slab * sc);
FORWARD void ddekit_slab_unlock(struct ddekit_slab * sc);
FORWARD struct ddekit_slab_slab * ddekit_slab_find_slab(struct
static void ddekit_slab_lock(struct ddekit_slab * sc);
static void ddekit_slab_unlock(struct ddekit_slab * sc);
static struct ddekit_slab_slab * ddekit_slab_find_slab(struct
ddekit_slab * sc, void * obj);
FORWARD void ddekit_slab_slab_insert(struct ddekit_slab_slab *list,
static void ddekit_slab_slab_insert(struct ddekit_slab_slab *list,
struct ddekit_slab_slab *s);
FORWARD void ddekit_slab_slab_remove(struct ddekit_slab_slab *s);
FORWARD void ddekit_slab_grow(struct ddekit_slab * sc);
FORWARD void *ddekit_slab_getobj(struct ddekit_slab_slab *s);
FORWARD void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int
static void ddekit_slab_slab_remove(struct ddekit_slab_slab *s);
static void ddekit_slab_grow(struct ddekit_slab * sc);
static void *ddekit_slab_getobj(struct ddekit_slab_slab *s);
static void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int
cont);
/******************************************************************************
* ddekit_simple_malloc *
*****************************************************************************/
PUBLIC void *ddekit_simple_malloc(unsigned size)
void *ddekit_simple_malloc(unsigned size)
{
/* Simple memory allocation... malloc and free should be ok... */
void * r = malloc(size);
@@ -67,7 +67,7 @@ PUBLIC void *ddekit_simple_malloc(unsigned size)
/******************************************************************************
* ddekit_simple_free *
*****************************************************************************/
PUBLIC void ddekit_simple_free(void *p)
void ddekit_simple_free(void *p)
{
DDEBUG_MSG_VERBOSE("%p", p);
free(p);
@@ -76,7 +76,7 @@ PUBLIC void ddekit_simple_free(void *p)
/******************************************************************************
* ddekit_large_malloc *
*****************************************************************************/
PUBLIC void *ddekit_large_malloc(int size)
void *ddekit_large_malloc(int size)
{
ddekit_addr_t phys;
/* allocate a piece of coniguous memory */
@@ -93,7 +93,7 @@ PUBLIC void *ddekit_large_malloc(int size)
/******************************************************************************
* ddekit_large_free *
*****************************************************************************/
PUBLIC void ddekit_large_free(void *p)
void ddekit_large_free(void *p)
{
unsigned len;
DDEBUG_MSG_VERBOSE("get size of region %x", p);
@@ -109,7 +109,7 @@ PUBLIC void ddekit_large_free(void *p)
/******************************************************************************
* ddekit_contig_malloc *
*****************************************************************************/
PUBLIC void *ddekit_contig_malloc(unsigned long size, unsigned long low,
void *ddekit_contig_malloc(unsigned long size, unsigned long low,
unsigned long high, unsigned long aligment,
unsigned long boundary)
{
@@ -120,21 +120,21 @@ PUBLIC void *ddekit_contig_malloc(unsigned long size, unsigned long low,
/******************************************************************************
* ddekit_slab_lock *
*****************************************************************************/
PRIVATE DDEKIT_INLINE void ddekit_slab_lock(struct ddekit_slab * sc) {
static DDEKIT_INLINE void ddekit_slab_lock(struct ddekit_slab * sc) {
ddekit_lock_lock(&sc->lock);
}
/******************************************************************************
* ddekit_slab_unlock *
*****************************************************************************/
PRIVATE DDEKIT_INLINE void ddekit_slab_unlock(struct ddekit_slab * sc) {
static DDEKIT_INLINE void ddekit_slab_unlock(struct ddekit_slab * sc) {
ddekit_lock_unlock(&sc->lock);
}
/******************************************************************************
* ddekit_slab_find_slab *
*****************************************************************************/
PRIVATE struct ddekit_slab_slab *
static struct ddekit_slab_slab *
ddekit_slab_find_slab(struct ddekit_slab * sc, void * obj)
{
@@ -174,7 +174,7 @@ static void ddekit_slab_slab_insert(struct ddekit_slab_slab *list,
/******************************************************************************
* ddekit_slab_slab_remove *
*****************************************************************************/
PRIVATE void ddekit_slab_slab_remove(struct ddekit_slab_slab *s)
static void ddekit_slab_slab_remove(struct ddekit_slab_slab *s)
{
s->next->prev = s->prev;
s->prev->next = s->next;
@@ -185,7 +185,7 @@ PRIVATE void ddekit_slab_slab_remove(struct ddekit_slab_slab *s)
/******************************************************************************
* ddekit_slab_grow *
*****************************************************************************/
PRIVATE void ddekit_slab_grow(struct ddekit_slab *sc)
static void ddekit_slab_grow(struct ddekit_slab *sc)
{
/*
* NOTE:
@@ -249,7 +249,7 @@ PRIVATE void ddekit_slab_grow(struct ddekit_slab *sc)
/******************************************************************************
* ddekit_slab_getobj *
*****************************************************************************/
PRIVATE void *ddekit_slab_getobj(struct ddekit_slab_slab *s)
static void *ddekit_slab_getobj(struct ddekit_slab_slab *s)
{
struct ddekit_slab *sc;
void *ret = 0;
@@ -284,7 +284,7 @@ PRIVATE void *ddekit_slab_getobj(struct ddekit_slab_slab *s)
/******************************************************************************
* ddekit_slab_alloc *
*****************************************************************************/
PUBLIC void *ddekit_slab_alloc(struct ddekit_slab * sc)
void *ddekit_slab_alloc(struct ddekit_slab * sc)
{
struct ddekit_slab_slab *s=0;
@@ -318,7 +318,7 @@ PUBLIC void *ddekit_slab_alloc(struct ddekit_slab * sc)
/******************************************************************************
* ddekit_slab_free *
*****************************************************************************/
PUBLIC void ddekit_slab_free(struct ddekit_slab *sc, void* obj)
void ddekit_slab_free(struct ddekit_slab *sc, void* obj)
{
void **p;
@@ -354,7 +354,7 @@ PUBLIC void ddekit_slab_free(struct ddekit_slab *sc, void* obj)
/******************************************************************************
* ddekit_slab_set_data *
*****************************************************************************/
PUBLIC void ddekit_slab_set_data(struct ddekit_slab * sc, void *data)
void ddekit_slab_set_data(struct ddekit_slab * sc, void *data)
{
ddekit_slab_lock(sc);
sc->data = data;
@@ -364,7 +364,7 @@ PUBLIC void ddekit_slab_set_data(struct ddekit_slab * sc, void *data)
/******************************************************************************
* ddekit_slab_get_data *
*****************************************************************************/
PUBLIC void *ddekit_slab_get_data (struct ddekit_slab *sc)
void *ddekit_slab_get_data (struct ddekit_slab *sc)
{
void *ret;
ddekit_slab_lock(sc);
@@ -377,7 +377,7 @@ PUBLIC void *ddekit_slab_get_data (struct ddekit_slab *sc)
/******************************************************************************
* ddekit_slab_init *
*****************************************************************************/
PUBLIC struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous)
struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous)
{
struct ddekit_slab * sc = 0;
@@ -412,7 +412,7 @@ PUBLIC struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous)
/******************************************************************************
* ddekit_slab_free_slab *
*****************************************************************************/
PRIVATE void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int cont)
static void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int cont)
{
struct ddekit_slab_slab *s,*t;
@@ -442,7 +442,7 @@ PRIVATE void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int cont)
/******************************************************************************
* ddekit_slab_destroy *
*****************************************************************************/
PUBLIC void ddekit_slab_destroy(struct ddekit_slab *sc)
void ddekit_slab_destroy(struct ddekit_slab *sc)
{
DDEBUG_MSG_VERBOSE("%p full", sc);
ddekit_slab_free_slab(&sc->full,sc->contiguous);

12
lib/libddekit/src/msg_queue.c
View File

@@ -25,14 +25,14 @@ struct ddekit_minix_msg_q {
struct ddekit_minix_msg_q *next;
};
PRIVATE struct ddekit_minix_msg_q * _list = NULL;
FORWARD void _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq,
static struct ddekit_minix_msg_q * _list = NULL;
static void _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq,
message *m);
/*****************************************************************************
* ddekit_minix_create_msg_q *
****************************************************************************/
PUBLIC struct ddekit_minix_msg_q *
struct ddekit_minix_msg_q *
ddekit_minix_create_msg_q(unsigned from, unsigned to)
{
struct ddekit_minix_msg_q *mq = (struct ddekit_minix_msg_q *)
@@ -58,7 +58,7 @@ ddekit_minix_create_msg_q(unsigned from, unsigned to)
/*****************************************************************************
* ddekit_minix_deregister_msg_q *
****************************************************************************/
PUBLIC void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
{
struct ddekit_minix_msg_q *prev =_list, *it;
@@ -81,7 +81,7 @@ PUBLIC void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
/*****************************************************************************
* _ddekit_minix_queue_msg *
****************************************************************************/
PRIVATE void
static void
_ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq, message *m)
{
int full;
@@ -137,7 +137,7 @@ void ddekit_minix_queue_msg(message *m)
/*****************************************************************************
* ddekit_minix_rcv *
****************************************************************************/
PUBLIC void ddekit_minix_rcv(struct ddekit_minix_msg_q *mq, message *m)
void ddekit_minix_rcv(struct ddekit_minix_msg_q *mq, message *m)
{
DDEBUG_MSG_VERBOSE("waiting for message");

4
lib/libddekit/src/panic.c
View File

@@ -5,7 +5,7 @@
/****************************************************************************/
/* ddekit_panic */
/****************************************************************************/
PUBLIC void ddekit_panic(char *fmt, ...)
void ddekit_panic(char *fmt, ...)
{
int r;
@@ -24,7 +24,7 @@ PUBLIC void ddekit_panic(char *fmt, ...)
/****************************************************************************/
/* ddekit_debug */
/****************************************************************************/
PUBLIC void ddekit_debug(char *fmt, ...)
void ddekit_debug(char *fmt, ...)
{
int r;
va_list va;

52
lib/libddekit/src/pci.c
View File

@@ -34,13 +34,13 @@ struct ddekit_pci_dev {
struct ddekit_pci_dev pci_devs[PCI_MAX_DEVS];
FORWARD struct ddekit_pci_dev * ddekit_get_dev_helper(int bus, int slot,
static struct ddekit_pci_dev * ddekit_get_dev_helper(int bus, int slot,
int func);
/****************************************************************************/
/* ddekit_pci_init_only_one */
/****************************************************************************/
PUBLIC void ddekit_pci_init_only_one(int skip)
void ddekit_pci_init_only_one(int skip)
{
/*
* If skip is not PCI_TAKE_ALL this function will skip skip PCI DEVICES
@@ -108,7 +108,7 @@ PUBLIC void ddekit_pci_init_only_one(int skip)
/****************************************************************************/
/* ddekit_pci_get_device_id */
/****************************************************************************/
PUBLIC void ddekit_pci_init(void)
void ddekit_pci_init(void)
{
ddekit_pci_init_only_one(DDEKIT_PCI_ANY_ID);
}
@@ -133,7 +133,7 @@ int ddekit_pci_get_device(int nr, int *bus, int *slot, int *func)
/****************************************************************************/
/* ddekit_pci_get_device_id */
/****************************************************************************/
PRIVATE struct ddekit_pci_dev *
static struct ddekit_pci_dev *
ddekit_get_dev_helper(int bus, int slot, int func)
{
/*
@@ -153,7 +153,7 @@ ddekit_get_dev_helper(int bus, int slot, int func)
/****************************************************************************/
/* ddekit_pci_read */
/****************************************************************************/
PUBLIC int ddekit_pci_read
int ddekit_pci_read
(int bus, int slot, int func, int pos, int len, ddekit_uint32_t *val)
{
switch(len) {
@@ -172,7 +172,7 @@ PUBLIC int ddekit_pci_read
/****************************************************************************/
/* ddekit_pci_write */
/****************************************************************************/
PUBLIC int ddekit_pci_write
int ddekit_pci_write
(int bus, int slot, int func, int pos, int len, ddekit_uint32_t val)
{
switch(len) {
@@ -191,7 +191,7 @@ PUBLIC int ddekit_pci_write
/****************************************************************************/
/* ddekit_pci_readb */
/****************************************************************************/
PUBLIC 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) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (func!=0) {
*val=0;
@@ -209,7 +209,7 @@ PUBLIC int ddekit_pci_readb (int bus, int slot, int func, int pos, ddekit_uint8_
/****************************************************************************/
/* ddekit_pci_readw */
/****************************************************************************/
PUBLIC int ddekit_pci_readw
int ddekit_pci_readw
(int bus, int slot, int func, int pos, ddekit_uint16_t *val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (func!=0) {
@@ -228,7 +228,7 @@ PUBLIC int ddekit_pci_readw
/****************************************************************************/
/* ddekit_pci_readl */
/****************************************************************************/
PUBLIC int ddekit_pci_readl
int ddekit_pci_readl
(int bus, int slot, int func, int pos, ddekit_uint32_t *val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (func!=0) {
@@ -247,7 +247,7 @@ PUBLIC int ddekit_pci_readl
/****************************************************************************/
/* ddekit_pci_writeb */
/****************************************************************************/
PUBLIC int ddekit_pci_writeb
int ddekit_pci_writeb
(int bus, int slot, int func, int pos, ddekit_uint8_t val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (dev) {
@@ -262,7 +262,7 @@ PUBLIC int ddekit_pci_writeb
/****************************************************************************/
/* ddekit_pci_writel */
/****************************************************************************/
PUBLIC int ddekit_pci_writew
int ddekit_pci_writew
(int bus, int slot, int func, int pos, ddekit_uint16_t val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (dev) {
@@ -277,7 +277,7 @@ PUBLIC int ddekit_pci_writew
/****************************************************************************/
/* ddekit_pci_writel */
/****************************************************************************/
PUBLIC int ddekit_pci_writel
int ddekit_pci_writel
(int bus, int slot, int func, int pos, ddekit_uint32_t val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (dev) {
@@ -291,7 +291,7 @@ PUBLIC int ddekit_pci_writel
/****************************************************************************/
/* ddekit_pci_find_device */
/****************************************************************************/
PUBLIC struct ddekit_pci_dev *ddekit_pci_find_device
struct ddekit_pci_dev *ddekit_pci_find_device
(int *bus, int *slot, int *func, struct ddekit_pci_dev *start)
{
int i,search=0;
@@ -323,7 +323,7 @@ PUBLIC struct ddekit_pci_dev *ddekit_pci_find_device
/****************************************************************************/
/* ddekit_pci_get_vendor */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev)
{
return dev->vid;
}
@@ -331,7 +331,7 @@ PUBLIC unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_device_id */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev)
{
return dev->did;
}
@@ -344,7 +344,7 @@ PUBLIC unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_enable_device */
/****************************************************************************/
PUBLIC int ddekit_pci_enable_device(struct ddekit_pci_dev *dev)
int ddekit_pci_enable_device(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -353,7 +353,7 @@ PUBLIC int ddekit_pci_enable_device(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_disable_device */
/****************************************************************************/
PUBLIC int ddekit_pci_disable_device(struct ddekit_pci_dev *dev)
int ddekit_pci_disable_device(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -362,7 +362,7 @@ PUBLIC int ddekit_pci_disable_device(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_set_master */
/****************************************************************************/
PUBLIC void ddekit_pci_set_master(struct ddekit_pci_dev *dev)
void ddekit_pci_set_master(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
}
@@ -371,7 +371,7 @@ PUBLIC void ddekit_pci_set_master(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_sub_vendor */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -380,7 +380,7 @@ PUBLIC unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_sub_device */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -389,7 +389,7 @@ PUBLIC unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_dev_class */
/****************************************************************************/
PUBLIC unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev)
unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -398,7 +398,7 @@ PUBLIC unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_irq */
/****************************************************************************/
PUBLIC unsigned long
unsigned long
ddekit_pci_get_irq(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
@@ -408,7 +408,7 @@ ddekit_pci_get_irq(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_name */
/****************************************************************************/
PUBLIC char *ddekit_pci_get_name(struct ddekit_pci_dev *dev)
char *ddekit_pci_get_name(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -417,7 +417,7 @@ PUBLIC char *ddekit_pci_get_name(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_slot_name */
/****************************************************************************/
PUBLIC char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev)
char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -426,7 +426,7 @@ PUBLIC char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_resource */
/****************************************************************************/
PUBLIC ddekit_pci_res_t *
ddekit_pci_res_t *
ddekit_pci_get_resource(struct ddekit_pci_dev *dev, unsigned int idx)
{
WARN_UNIMPL;
@@ -436,7 +436,7 @@ ddekit_pci_get_resource(struct ddekit_pci_dev *dev, unsigned int idx)
/****************************************************************************/
/* ddekit_pci_irq_enable */
/****************************************************************************/
PUBLIC int ddekit_pci_irq_enable
int ddekit_pci_irq_enable
(int bus, int slot, int func, int pin, int *irq)
{
/* call not needed */

54
lib/libddekit/src/pgtab.c
View File

@@ -23,14 +23,14 @@
#include "debug.h"
FORWARD void lock_pgtab(void);
FORWARD void unlock_pgtab(void);
FORWARD struct dde_pgtab_region * allocate_region(void);
FORWARD void free_region(struct dde_pgtab_region *r);
FORWARD void add_region(struct dde_pgtab_region *r);
FORWARD void rm_region(struct dde_pgtab_region *r);
FORWARD struct dde_pgtab_region * find_region_virt(ddekit_addr_t va);
FORWARD struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa);
static void lock_pgtab(void);
static void unlock_pgtab(void);
static struct dde_pgtab_region * allocate_region(void);
static void free_region(struct dde_pgtab_region *r);
static void add_region(struct dde_pgtab_region *r);
static void rm_region(struct dde_pgtab_region *r);
static struct dde_pgtab_region * find_region_virt(ddekit_addr_t va);
static struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa);
struct dde_pgtab_region {
ddekit_addr_t vm_start;
@@ -41,8 +41,8 @@ struct dde_pgtab_region {
struct dde_pgtab_region *prev;
};
PRIVATE struct dde_pgtab_region head = {0,0,0,0,&head,&head};
PRIVATE ddekit_lock_t lock;
static struct dde_pgtab_region head = {0,0,0,0,&head,&head};
static ddekit_lock_t lock;
/*
* INTERNAL HELPERS
@@ -51,7 +51,7 @@ PRIVATE ddekit_lock_t lock;
/****************************************************************************/
/* lock_pgtab */
/****************************************************************************/
PRIVATE void lock_pgtab()
static void lock_pgtab()
{
ddekit_lock_lock(&lock);
}
@@ -60,7 +60,7 @@ PRIVATE void lock_pgtab()
/****************************************************************************/
/* unlock_pgtab */
/****************************************************************************/
PRIVATE void unlock_pgtab()
static void unlock_pgtab()
{
ddekit_lock_unlock(&lock);
}
@@ -68,7 +68,7 @@ PRIVATE void unlock_pgtab()
/****************************************************************************/
/* dde_pgtab_region */
/****************************************************************************/
PRIVATE struct dde_pgtab_region * allocate_region()
static struct dde_pgtab_region * allocate_region()
{
struct dde_pgtab_region * res;
@@ -84,7 +84,7 @@ PRIVATE struct dde_pgtab_region * allocate_region()
/****************************************************************************/
/* free_region */
/****************************************************************************/
PRIVATE void free_region(struct dde_pgtab_region *r)
static void free_region(struct dde_pgtab_region *r)
{
ddekit_simple_free(r);
}
@@ -92,7 +92,7 @@ PRIVATE void free_region(struct dde_pgtab_region *r)
/****************************************************************************/
/* add_region */
/****************************************************************************/
PRIVATE void add_region (struct dde_pgtab_region *r)
static void add_region (struct dde_pgtab_region *r)
{
r->next = head.next;
head.next = r;
@@ -108,7 +108,7 @@ PRIVATE void add_region (struct dde_pgtab_region *r)
/****************************************************************************/
/* rm_region */
/****************************************************************************/
PRIVATE void rm_region(struct dde_pgtab_region *r)
static void rm_region(struct dde_pgtab_region *r)
{
if (r->next) {
r->next->prev = r->prev;
@@ -124,7 +124,7 @@ PRIVATE void rm_region(struct dde_pgtab_region *r)
/****************************************************************************/
/* find_region_virt */
/****************************************************************************/
PRIVATE struct dde_pgtab_region * find_region_virt(ddekit_addr_t va)
static struct dde_pgtab_region * find_region_virt(ddekit_addr_t va)
{
struct dde_pgtab_region * r;
@@ -146,7 +146,7 @@ PRIVATE struct dde_pgtab_region * find_region_virt(ddekit_addr_t va)
/****************************************************************************/
/* find_region_phys */
/****************************************************************************/
PRIVATE struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa)
static struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa)
{
struct dde_pgtab_region * r;
@@ -166,7 +166,7 @@ PRIVATE struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa)
/****************************************************************************/
/* ddekit_pgtab_do_fo_each_region */
/****************************************************************************/
PUBLIC void ddekit_pgtab_do_fo_each_region(void (*func) (unsigned, unsigned)) {
void ddekit_pgtab_do_fo_each_region(void (*func) (unsigned, unsigned)) {
struct dde_pgtab_region * r;
for( r = head.next; r != &head ; r = r->next ) {
@@ -182,7 +182,7 @@ PUBLIC void ddekit_pgtab_do_fo_each_region(void (*func) (unsigned, unsigned)) {
/****************************************************************************/
/* ddekit_pgtab_set_region */
/****************************************************************************/
PUBLIC 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)
{
ddekit_pgtab_set_region_with_size(virt, phys, (4096)*pages, type);
}
@@ -190,7 +190,7 @@ PUBLIC void ddekit_pgtab_set_region(void *virt, ddekit_addr_t phys, int pages, i
/****************************************************************************/
/* ddekit_pgtab_set_region_with_size */
/****************************************************************************/
PUBLIC 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)
{
struct dde_pgtab_region * r;
@@ -212,7 +212,7 @@ PUBLIC void ddekit_pgtab_set_region_with_size(void *virt, ddekit_addr_t phys, in
/****************************************************************************/
/* ddekit_pgtab_clear_region */
/****************************************************************************/
PUBLIC void ddekit_pgtab_clear_region(void *virt, int type) {
void ddekit_pgtab_clear_region(void *virt, int type) {
struct dde_pgtab_region *r;
@@ -234,7 +234,7 @@ PUBLIC void ddekit_pgtab_clear_region(void *virt, int type) {
/****************************************************************************/
/* ddekit_pgtab_get_physaddr */
/****************************************************************************/
PUBLIC ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt)
ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt)
{
struct dde_pgtab_region *r;
ddekit_addr_t ret = 0;
@@ -253,7 +253,7 @@ PUBLIC ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt)
/****************************************************************************/
/* ddekit_pgtab_get_virtaddr */
/****************************************************************************/
PUBLIC ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical)
ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical)
{
struct dde_pgtab_region *r;
lock_pgtab();
@@ -270,7 +270,7 @@ PUBLIC ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical)
/****************************************************************************/
/* ddekit_pgtab_get_size */
/****************************************************************************/
PUBLIC int ddekit_pgtab_get_type(const void *virt)
int ddekit_pgtab_get_type(const void *virt)
{
/*
* needed for dde fbsd
@@ -287,7 +287,7 @@ PUBLIC int ddekit_pgtab_get_type(const void *virt)
/****************************************************************************/
/* ddekit_pgtab_get_size */
/****************************************************************************/
PUBLIC int ddekit_pgtab_get_size(const void *virt)
int ddekit_pgtab_get_size(const void *virt)
{
/*
* needed for fbsd
@@ -306,7 +306,7 @@ PUBLIC int ddekit_pgtab_get_size(const void *virt)
/****************************************************************************/
/* ddekit_pgtab_init */
/****************************************************************************/
PUBLIC void ddekit_pgtab_init() {
void ddekit_pgtab_init() {
/* called by ddekit_init() */
ddekit_lock_init(&lock);
}

6
lib/libddekit/src/printf.c
View File

@@ -4,7 +4,7 @@
/****************************************************************************/
/* ddekit_print */
/****************************************************************************/
PUBLIC int ddekit_print(const char* c)
int ddekit_print(const char* c)
{
return ddekit_printf(c);
}
@@ -12,7 +12,7 @@ PUBLIC int ddekit_print(const char* c)
/****************************************************************************/
/* ddekit_printf */
/****************************************************************************/
PUBLIC int ddekit_printf(const char* fmt, ...)
int ddekit_printf(const char* fmt, ...)
{
int r;
va_list va;
@@ -27,7 +27,7 @@ PUBLIC int ddekit_printf(const char* fmt, ...)
/****************************************************************************/
/* ddekit_vprintf */
/****************************************************************************/
PUBLIC int ddekit_vprintf(const char *fmt, va_list va)
int ddekit_vprintf(const char *fmt, va_list va)
{
return vprintf(fmt, va);
}

24
lib/libddekit/src/resource.c
View File

@@ -16,7 +16,7 @@
/****************************************************************************/
/* ddekit_release_dma */
/****************************************************************************/
PUBLIC int ddekit_request_dma(int nr) {
int ddekit_request_dma(int nr) {
WARN_UNIMPL;
/* do we stil use isa dma ? imho no.*/
return -1;
@@ -25,7 +25,7 @@ PUBLIC int ddekit_request_dma(int nr) {
/****************************************************************************/
/* ddekit_request_dma */
/****************************************************************************/
PUBLIC int ddekit_release_dma(int nr) {
int ddekit_release_dma(int nr) {
WARN_UNIMPL;
/* do we stil use isa dma ? imho no.*/
return -1;
@@ -37,17 +37,17 @@ PUBLIC int ddekit_release_dma(int nr) {
/****************************************************************************/
/* ddekit_release/request_io */
/****************************************************************************/
PUBLIC int ddekit_request_io (ddekit_addr_t start, ddekit_addr_t count) {
int ddekit_request_io (ddekit_addr_t start, ddekit_addr_t count) {
return 0;
}
PUBLIC int ddekit_release_io (ddekit_addr_t start, ddekit_addr_t count) {
int ddekit_release_io (ddekit_addr_t start, ddekit_addr_t count) {
return 0;
}
/****************************************************************************/
/* ddekit_request_mem */
/****************************************************************************/
PUBLIC int ddekit_request_mem
int ddekit_request_mem
(ddekit_addr_t start, ddekit_addr_t size, ddekit_addr_t *vaddr) {
*vaddr = (ddekit_addr_t) vm_map_phys(SELF, (void *)start, size);
@@ -64,7 +64,7 @@ PUBLIC int ddekit_request_mem
/****************************************************************************/
/* ddekit_release_mem */
/****************************************************************************/
PUBLIC int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t size)
int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t size)
{
return vm_unmap_phys(SELF,(void *) start, size );
}
@@ -72,7 +72,7 @@ PUBLIC int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t size)
/****************************************************************************/
/* ddekit_inb */
/****************************************************************************/
PUBLIC unsigned char ddekit_inb(ddekit_addr_t port) {
unsigned char ddekit_inb(ddekit_addr_t port) {
u32_t ret;
if (sys_inb(port, &ret)) {
ddekit_panic("sys_inb failed.");
@@ -84,7 +84,7 @@ PUBLIC unsigned char ddekit_inb(ddekit_addr_t port) {
/****************************************************************************/
/* ddekit_inw */
/****************************************************************************/
PUBLIC unsigned short ddekit_inw(ddekit_addr_t port) {
unsigned short ddekit_inw(ddekit_addr_t port) {
u32_t ret;
if (sys_inw(port, &ret)) {
ddekit_panic("sys_inw failed.");
@@ -96,7 +96,7 @@ PUBLIC unsigned short ddekit_inw(ddekit_addr_t port) {
/****************************************************************************/
/* ddekit_inl */
/****************************************************************************/
PUBLIC unsigned long ddekit_inl(ddekit_addr_t port){
unsigned long ddekit_inl(ddekit_addr_t port){
u32_t ret;
if (sys_inl(port, &ret)) {
ddekit_panic("sys_outl failed.");
@@ -108,7 +108,7 @@ PUBLIC unsigned long ddekit_inl(ddekit_addr_t port){
/****************************************************************************/
/* ddekit_outb */
/****************************************************************************/
PUBLIC void ddekit_outb(ddekit_addr_t port, unsigned char val) {
void ddekit_outb(ddekit_addr_t port, unsigned char val) {
if (sys_outb(port,val)) {
ddekit_panic("sys_outb failed.");
}
@@ -118,7 +118,7 @@ PUBLIC void ddekit_outb(ddekit_addr_t port, unsigned char val) {
/****************************************************************************/
/* ddekit_outw */
/****************************************************************************/
PUBLIC void ddekit_outw(ddekit_addr_t port, unsigned short val) {
void ddekit_outw(ddekit_addr_t port, unsigned short val) {
if (sys_outw(port,val)) {
ddekit_panic("sys_outw failed.");
}
@@ -128,7 +128,7 @@ PUBLIC void ddekit_outw(ddekit_addr_t port, unsigned short val) {
/****************************************************************************/
/* ddekit_outl */
/****************************************************************************/
PUBLIC void ddekit_outl(ddekit_addr_t port, unsigned long val) {
void ddekit_outl(ddekit_addr_t port, unsigned long val) {
if (sys_outl(port,val)) {
ddekit_panic("sys_outl failed.");
}

12
lib/libddekit/src/semaphore.c
View File

@@ -26,7 +26,7 @@ struct ddekit_sem {
/*****************************************************************************
* ddekit_sem_init *
*************************+**************************************************/
PUBLIC ddekit_sem_t *ddekit_sem_init(int value)
ddekit_sem_t *ddekit_sem_init(int value)
{
ddekit_sem_t *sem;
@@ -42,7 +42,7 @@ PUBLIC ddekit_sem_t *ddekit_sem_init(int value)
/*****************************************************************************
* ddekit_sem_deinit *
****************************************************************************/
PUBLIC void ddekit_sem_deinit(ddekit_sem_t *sem)
void ddekit_sem_deinit(ddekit_sem_t *sem)
{
SEM_DEBUG(p);
ddekit_simple_free(sem);
@@ -51,7 +51,7 @@ PUBLIC void ddekit_sem_deinit(ddekit_sem_t *sem)
/*****************************************************************************
* ddekit_sem_down *
****************************************************************************/
PUBLIC void ddekit_sem_down(ddekit_sem_t *sem)
void ddekit_sem_down(ddekit_sem_t *sem)
{
SEM_DEBUG(p);
if(sem->count == 0) {
@@ -73,7 +73,7 @@ PUBLIC void ddekit_sem_down(ddekit_sem_t *sem)
/*****************************************************************************
* ddekit_sem_down_try *
****************************************************************************/
PUBLIC int ddekit_sem_down_try(ddekit_sem_t *sem)
int ddekit_sem_down_try(ddekit_sem_t *sem)
{
if(sem->count == 0) {
return -1;
@@ -85,7 +85,7 @@ PUBLIC int ddekit_sem_down_try(ddekit_sem_t *sem)
/*****************************************************************************
* ddekit_sem_up *
****************************************************************************/
PUBLIC void ddekit_sem_up(ddekit_sem_t *sem)
void ddekit_sem_up(ddekit_sem_t *sem)
{
SEM_DEBUG(p);
if (sem->wait_queue == NULL) {
@@ -103,7 +103,7 @@ PUBLIC void ddekit_sem_up(ddekit_sem_t *sem)
/****************************************************************************
* ddekit_sem_down_timed *
***************************************************************************/
PUBLIC int ddekit_sem_down_timed(ddekit_sem_t *sem, int timo )
int ddekit_sem_down_timed(ddekit_sem_t *sem, int timo )
{
ddekit_panic("not implemented!");
return 0;

60
lib/libddekit/src/thread.c
View File

@@ -17,22 +17,22 @@
/* Incremented to generate unique thread IDs */
PRIVATE unsigned id;
static unsigned id;
PRIVATE ddekit_thread_t *ready_queue[DDEKIT_THREAD_PRIOS];
static ddekit_thread_t *ready_queue[DDEKIT_THREAD_PRIOS];
PRIVATE ddekit_thread_t *sleep_queue;
static ddekit_thread_t *sleep_queue;
/* Handle to the running thread, set in _dde_kit_thread_schedule() */
PRIVATE ddekit_thread_t *current = NULL;
static ddekit_thread_t *current = NULL;
FORWARD void _ddekit_thread_start(ddekit_thread_t *th);
FORWARD void _ddekit_thread_sleep(unsigned long until);
static void _ddekit_thread_start(ddekit_thread_t *th);
static void _ddekit_thread_sleep(unsigned long until);
/*****************************************************************************
* _ddekit_thread_start *
****************************************************************************/
PRIVATE void _ddekit_thread_start(ddekit_thread_t *th)
static void _ddekit_thread_start(ddekit_thread_t *th)
{
/* entry point of newly created threads */
th->fun(th->arg);
@@ -42,7 +42,7 @@ PRIVATE void _ddekit_thread_start(ddekit_thread_t *th)
/*****************************************************************************
* _ddekit_thread_sleep *
****************************************************************************/
PRIVATE void _ddekit_thread_sleep(unsigned long until)
static void _ddekit_thread_sleep(unsigned long until)
{
current->next = sleep_queue;
sleep_queue = current;
@@ -58,7 +58,7 @@ PRIVATE void _ddekit_thread_sleep(unsigned long until)
/*****************************************************************************
* ddekit_yield *
****************************************************************************/
PUBLIC void ddekit_yield()
void ddekit_yield()
{
ddekit_thread_schedule();
}
@@ -66,7 +66,7 @@ PUBLIC void ddekit_yield()
/*****************************************************************************
* ddekit_thread_schedule *
****************************************************************************/
PUBLIC void ddekit_thread_schedule()
void ddekit_thread_schedule()
{
_ddekit_thread_enqueue(current);
_ddekit_thread_schedule();
@@ -75,7 +75,7 @@ PUBLIC void ddekit_thread_schedule()
/*****************************************************************************
* ddekit_thread_create *
****************************************************************************/
PUBLIC ddekit_thread_t *
ddekit_thread_t *
ddekit_thread_create(void (*fun)(void *), void *arg, const char *name)
{
ddekit_thread_t *th =
@@ -130,7 +130,7 @@ ddekit_thread_create(void (*fun)(void *), void *arg, const char *name)
/*****************************************************************************
* ddekit_thread_get_data *
****************************************************************************/
PUBLIC void *ddekit_thread_get_data(ddekit_thread_t *thread)
void *ddekit_thread_get_data(ddekit_thread_t *thread)
{
return thread->data;
}
@@ -138,7 +138,7 @@ PUBLIC void *ddekit_thread_get_data(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_thread_get_my_data *
****************************************************************************/
PUBLIC void *ddekit_thread_get_my_data(void)
void *ddekit_thread_get_my_data(void)
{
return current->data;
}
@@ -146,7 +146,7 @@ PUBLIC void *ddekit_thread_get_my_data(void)
/*****************************************************************************
* ddekit_thread_myself *
****************************************************************************/
PUBLIC
ddekit_thread_t *ddekit_thread_myself(void)
{
return current;
@@ -155,7 +155,7 @@ ddekit_thread_t *ddekit_thread_myself(void)
/*****************************************************************************
* ddekit_thread_setup_myself *
****************************************************************************/
PUBLIC
ddekit_thread_t *ddekit_thread_setup_myself(const char *name) {
ddekit_thread_t *th =
(ddekit_thread_t *) ddekit_simple_malloc(sizeof(ddekit_thread_t));
@@ -176,7 +176,7 @@ ddekit_thread_t *ddekit_thread_setup_myself(const char *name) {
/*****************************************************************************
* ddekit_thread_set_data *
****************************************************************************/
PUBLIC void ddekit_thread_set_data(ddekit_thread_t *thread, void *data)
void ddekit_thread_set_data(ddekit_thread_t *thread, void *data)
{
thread->data=data;
}
@@ -184,7 +184,7 @@ PUBLIC void ddekit_thread_set_data(ddekit_thread_t *thread, void *data)
/*****************************************************************************
* ddekit_thread_set_my_data *
****************************************************************************/
PUBLIC void ddekit_thread_set_my_data(void *data)
void ddekit_thread_set_my_data(void *data)
{
current->data = data;
}
@@ -217,7 +217,7 @@ void ddekit_thread_usleep(unsigned long usecs)
/*****************************************************************************
* ddekit_thread_nsleep *
****************************************************************************/
PUBLIC void ddekit_thread_nsleep(unsigned long nsecs)
void ddekit_thread_nsleep(unsigned long nsecs)
{
/*
* Cannot use usleep here, because it's implemented in vfs.
@@ -242,7 +242,7 @@ PUBLIC void ddekit_thread_nsleep(unsigned long nsecs)
/*****************************************************************************
* ddekit_thread_msleep *
****************************************************************************/
PUBLIC void ddekit_thread_msleep(unsigned long msecs)
void ddekit_thread_msleep(unsigned long msecs)
{
unsigned long to;
@@ -270,7 +270,7 @@ PUBLIC void ddekit_thread_msleep(unsigned long msecs)
/*****************************************************************************
* ddekit_thread_sleep *
****************************************************************************/
PUBLIC void ddekit_thread_sleep(ddekit_lock_t *lock)
void ddekit_thread_sleep(ddekit_lock_t *lock)
{
WARN_UNIMPL;
}
@@ -278,7 +278,7 @@ PUBLIC void ddekit_thread_sleep(ddekit_lock_t *lock)
/*****************************************************************************
* ddekit_thread_exit *
****************************************************************************/
PUBLIC void ddekit_thread_exit()
void ddekit_thread_exit()
{
ddekit_sem_down(current->sleep_sem);
ddekit_panic("thread running after exit!\n");
@@ -289,7 +289,7 @@ PUBLIC void ddekit_thread_exit()
/*****************************************************************************
* ddekit_thread_terminate *
****************************************************************************/
PUBLIC void ddekit_thread_terminate(ddekit_thread_t *thread)
void ddekit_thread_terminate(ddekit_thread_t *thread)
{
/* todo */
}
@@ -297,7 +297,7 @@ PUBLIC void ddekit_thread_terminate(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_thread_get_name *
****************************************************************************/
PUBLIC const char *ddekit_thread_get_name(ddekit_thread_t *thread)
const char *ddekit_thread_get_name(ddekit_thread_t *thread)
{
return thread->name;
}
@@ -305,7 +305,7 @@ PUBLIC const char *ddekit_thread_get_name(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_thread_get_id *
****************************************************************************/
PUBLIC int ddekit_thread_get_id(ddekit_thread_t *thread)
int ddekit_thread_get_id(ddekit_thread_t *thread)
{
return thread->id;
}
@@ -313,7 +313,7 @@ PUBLIC int ddekit_thread_get_id(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_init_threads *
****************************************************************************/
PUBLIC void ddekit_init_threads(void)
void ddekit_init_threads(void)
{
int i;
@@ -333,7 +333,7 @@ PUBLIC void ddekit_init_threads(void)
/*****************************************************************************
* _ddekit_thread_schedule *
****************************************************************************/
PUBLIC void _ddekit_thread_schedule()
void _ddekit_thread_schedule()
{
DDEBUG_MSG_VERBOSE("called schedule id: %d name %s, prio: %d",
@@ -381,7 +381,7 @@ PUBLIC void _ddekit_thread_schedule()
/*****************************************************************************
* _ddekit_thread_enqueue *
****************************************************************************/
PUBLIC void _ddekit_thread_enqueue(ddekit_thread_t *th)
void _ddekit_thread_enqueue(ddekit_thread_t *th)
{
DDEBUG_MSG_VERBOSE("enqueueing thread: id: %d name %s, prio: %d",
@@ -407,7 +407,7 @@ PUBLIC void _ddekit_thread_enqueue(ddekit_thread_t *th)
/*****************************************************************************
* _ddekit_thread_set_myprio *
****************************************************************************/
PUBLIC void _ddekit_thread_set_myprio(int prio)
void _ddekit_thread_set_myprio(int prio)
{
DDEBUG_MSG_VERBOSE("changing thread prio, id: %d name %s, old prio: %d, "
"new prio: %d", current->id, current->name, current->prio);
@@ -419,7 +419,7 @@ PUBLIC void _ddekit_thread_set_myprio(int prio)
/*****************************************************************************
* _ddekit_thread_wakeup_sleeping *
****************************************************************************/
PUBLIC void _ddekit_thread_wakeup_sleeping()
void _ddekit_thread_wakeup_sleeping()
{
ddekit_thread_t *th = sleep_queue;
@@ -464,7 +464,7 @@ PUBLIC void _ddekit_thread_wakeup_sleeping()
/*****************************************************************************
* _ddekit_print_backtrace *
****************************************************************************/
PUBLIC void _ddekit_print_backtrace(ddekit_thread_t *th)
void _ddekit_print_backtrace(ddekit_thread_t *th)
{
unsigned long bp, pc, hbp;

52
lib/libddekit/src/timer.c
View File

@@ -28,26 +28,26 @@ struct ddekit_timer_s {
};
PRIVATE ddekit_sem_t *pending_timer_ints;
static ddekit_sem_t *pending_timer_ints;
/* are we currently expecting a alarm notify? */
int _ddekit_timer_pending = 0;
PUBLIC unsigned long long jiffies;
PUBLIC unsigned long HZ;
unsigned long long jiffies;
unsigned long HZ;
PRIVATE struct ddekit_timer_s list = {0,0,-1,1,0};
PRIVATE int _id = 0 ;
PRIVATE ddekit_thread_t *th;
PRIVATE ddekit_lock_t lock;
static struct ddekit_timer_s list = {0,0,-1,1,0};
static int _id = 0 ;
static ddekit_thread_t *th;
static ddekit_lock_t lock;
FORWARD void lock_timer(void);
FORWARD void unlock_timer(void);
FORWARD clock_t get_current_clock(void);
FORWARD void remove_timer(int id);
FORWARD int insert_timer(struct ddekit_timer_s *t);
FORWARD struct ddekit_timer_s * get_next( myclock_t exp );
FORWARD void ddekit_timer_thread(void *data);
static void lock_timer(void);
static void unlock_timer(void);
static clock_t get_current_clock(void);
static void remove_timer(int id);
static int insert_timer(struct ddekit_timer_s *t);
static struct ddekit_timer_s * get_next( myclock_t exp );
static void ddekit_timer_thread(void *data);
/****************************************************************************
* Private funtions *
@@ -56,7 +56,7 @@ FORWARD void ddekit_timer_thread(void *data);
/*****************************************************************************
* lock_timer *
****************************************************************************/
PRIVATE void lock_timer()
static void lock_timer()
{
ddekit_lock_lock(&lock);
}
@@ -83,7 +83,7 @@ static myclock_t get_current_clock()
/*****************************************************************************
* remove_timer *
****************************************************************************/
PRIVATE void remove_timer(int id)
static void remove_timer(int id)
{
/* removes a timer from the timer list */
struct ddekit_timer_s *l,*m;
@@ -112,7 +112,7 @@ PRIVATE void remove_timer(int id)
/*****************************************************************************
* insert_timer *
****************************************************************************/
PRIVATE int insert_timer(struct ddekit_timer_s *t)
static int insert_timer(struct ddekit_timer_s *t)
{
/* inserts a timer to the timer list */
int ret;
@@ -146,7 +146,7 @@ PRIVATE int insert_timer(struct ddekit_timer_s *t)
/*****************************************************************************
* get_next *
****************************************************************************/
PRIVATE struct ddekit_timer_s * get_next( myclock_t exp )
static struct ddekit_timer_s * get_next( myclock_t exp )
{
/*
* this one get the next timer, which's timeout expired,
@@ -169,7 +169,7 @@ PRIVATE struct ddekit_timer_s * get_next( myclock_t exp )
/*****************************************************************************
* ddekit_timer_thread *
****************************************************************************/
PRIVATE void ddekit_timer_thread(void * data)
static void ddekit_timer_thread(void * data)
{
struct ddekit_timer_s * l;
@@ -199,7 +199,7 @@ PRIVATE void ddekit_timer_thread(void * data)
/*****************************************************************************
* ddekit_add_timer *
****************************************************************************/
PUBLIC int ddekit_add_timer
int ddekit_add_timer
(void (*fn)(void *), void *args, unsigned long timeout)
{
struct ddekit_timer_s *t;
@@ -217,7 +217,7 @@ PUBLIC int ddekit_add_timer
/*****************************************************************************
* ddekit_del_timer *
****************************************************************************/
PUBLIC int ddekit_del_timer(int timer)
int ddekit_del_timer(int timer)
{
remove_timer(timer);
return 0;
@@ -226,7 +226,7 @@ PUBLIC int ddekit_del_timer(int timer)
/*****************************************************************************
* ddekit_timer_pending *
****************************************************************************/
PUBLIC int ddekit_timer_pending(int timer)
int ddekit_timer_pending(int timer)
{
int ret=0;
struct ddekit_timer_s *t;
@@ -244,7 +244,7 @@ PUBLIC int ddekit_timer_pending(int timer)
/*****************************************************************************
* ddekit_init_timers *
****************************************************************************/
PUBLIC void ddekit_init_timers(void)
void ddekit_init_timers(void)
{
static int first_time=0;
@@ -263,7 +263,7 @@ PUBLIC void ddekit_init_timers(void)
/*****************************************************************************
* ddekit_get_timer_thread *
****************************************************************************/
PUBLIC ddekit_thread_t *ddekit_get_timer_thread(void)
ddekit_thread_t *ddekit_get_timer_thread(void)
{
return th;
}
@@ -275,7 +275,7 @@ PUBLIC ddekit_thread_t *ddekit_get_timer_thread(void)
/*****************************************************************************
* _ddekit_timer_interrupt *
****************************************************************************/
PUBLIC void _ddekit_timer_interrupt(void)
void _ddekit_timer_interrupt(void)
{
jiffies = get_current_clock();
DDEBUG_MSG_VERBOSE("now: %d", jiffies);
@@ -285,7 +285,7 @@ PUBLIC void _ddekit_timer_interrupt(void)
/*****************************************************************************
* _ddekit_timer_update *
****************************************************************************/
PUBLIC void _ddekit_timer_update()
void _ddekit_timer_update()
{
lock_timer();

24
lib/libddekit/src/usb_client.c
View File

@@ -17,12 +17,12 @@ struct ddekit_usb_dev dev_list_head = {
.prev = &dev_list_head,
};
PRIVATE struct ddekit_usb_driver *d_usb_driver;
static struct ddekit_usb_driver *d_usb_driver;
FORWARD void _ddekit_usb_completion(struct usb_urb *mx);
FORWARD void _ddekit_usb_connect( unsigned int dev_id, unsigned int
static void _ddekit_usb_completion(struct usb_urb *mx);
static void _ddekit_usb_connect( unsigned int dev_id, unsigned int
interfaces);
FORWARD void _ddekit_usb_disconnect(unsigned dev_id);
static void _ddekit_usb_disconnect(unsigned dev_id);
struct usb_driver mx_usb_driver = {
.urb_completion = _ddekit_usb_completion,
@@ -33,7 +33,7 @@ struct usb_driver mx_usb_driver = {
/*****************************************************************************
* _ddekit_usb_completion *
****************************************************************************/
PRIVATE void _ddekit_usb_completion(struct usb_urb *mx_urb)
static void _ddekit_usb_completion(struct usb_urb *mx_urb)
{
struct ddekit_usb_urb *d_urb = (struct ddekit_usb_urb *) mx_urb->priv;
@@ -72,7 +72,7 @@ PRIVATE void _ddekit_usb_completion(struct usb_urb *mx_urb)
/*****************************************************************************
* _ddekit_usb_connect *
****************************************************************************/
PRIVATE void _ddekit_usb_connect(unsigned int dev_id, unsigned int interfaces)
static void _ddekit_usb_connect(unsigned int dev_id, unsigned int interfaces)
{
struct ddekit_usb_dev *d_dev = (struct ddekit_usb_dev *)
ddekit_simple_malloc(sizeof(struct ddekit_usb_dev));
@@ -94,7 +94,7 @@ PRIVATE void _ddekit_usb_connect(unsigned int dev_id, unsigned int interfaces)
/*****************************************************************************
* _ddekit_usb_disconnect *
****************************************************************************/
PUBLIC void _ddekit_usb_disconnect(unsigned dev_id)
void _ddekit_usb_disconnect(unsigned dev_id)
{
/* find dev */
struct ddekit_usb_dev *it;
@@ -118,7 +118,7 @@ PUBLIC void _ddekit_usb_disconnect(unsigned dev_id)
/*****************************************************************************
* ddekit_usb_dev_set_data *
****************************************************************************/
PUBLIC int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data)
int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data)
{
dev->data = data;
return 0;
@@ -127,7 +127,7 @@ PUBLIC int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data)
/*****************************************************************************
* ddekit_usb_dev_get_data *
****************************************************************************/
PUBLIC void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev)
void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev)
{
return dev->data;
}
@@ -135,7 +135,7 @@ PUBLIC void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev)
/*****************************************************************************
* ddekit_usb_submit_urb *
****************************************************************************/
PUBLIC int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
{
int res;
unsigned urb_size = USB_URBSIZE(d_urb->size, d_urb->number_of_packets);
@@ -180,7 +180,7 @@ PUBLIC int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
/*****************************************************************************
* ddekit_usb_cancle_urb *
****************************************************************************/
PUBLIC int ddekit_usb_cancle_urb(struct ddekit_usb_urb *d_urb)
int ddekit_usb_cancle_urb(struct ddekit_usb_urb *d_urb)
{
int res;
@@ -208,7 +208,7 @@ static void _ddekit_usb_thread()
/*****************************************************************************
* ddekit_usb_init *
****************************************************************************/
PUBLIC int ddekit_usb_init
int ddekit_usb_init
(struct ddekit_usb_driver *drv,
ddekit_usb_malloc_fn *unused,
ddekit_usb_free_fn *_unused)

88
lib/libddekit/src/usb_server.c
View File

@@ -58,29 +58,29 @@ struct minix_usb_device {
unsigned int interfaces;
};
FORWARD struct minix_usb_driver *find_driver(endpoint_t ep);
FORWARD struct minix_usb_driver *find_unused_driver(void);
FORWARD int add_to_pending_urbs(struct minix_usb_driver *drv, struct
static struct minix_usb_driver *find_driver(endpoint_t ep);
static struct minix_usb_driver *find_unused_driver(void);
static int add_to_pending_urbs(struct minix_usb_driver *drv, struct
ddekit_usb_urb *urb);
FORWARD int remove_from_pending_urbs(struct minix_usb_driver *drv,
static int remove_from_pending_urbs(struct minix_usb_driver *drv,
struct ddekit_usb_urb *urb);
FORWARD struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver
static struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver
*drv, unsigned urb_id);
FORWARD void register_driver(message *msg);
FORWARD struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb
static void register_driver(message *msg);
static struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb
*mx_urb);
FORWARD void submit_urb(message *msg);
FORWARD void cancle_urb(message *msg);
FORWARD void completion_callback(void *priv);
static void submit_urb(message *msg);
static void cancle_urb(message *msg);
static void completion_callback(void *priv);
FORWARD void prepare_devman_usbdev(struct ddekit_usb_dev * dev, int
static void prepare_devman_usbdev(struct ddekit_usb_dev * dev, int
dev_id, unsigned int interfaces, struct devman_usb_dev *dudev);
FORWARD void device_disconnect_callback(struct ddekit_usb_dev * dev);
FORWARD int add_acl(int dev_id, unsigned interfaces, endpoint_t ep);
FORWARD int del_acl(int dev_id, unsigned interaces, endpoint_t ep);
FORWARD int handle_msg(message *msg);
FORWARD void _ddekit_usb_thread();
FORWARD void device_connect_callback(struct ddekit_usb_dev * dev,
static void device_disconnect_callback(struct ddekit_usb_dev * dev);
static int add_acl(int dev_id, unsigned interfaces, endpoint_t ep);
static int del_acl(int dev_id, unsigned interaces, endpoint_t ep);
static int handle_msg(message *msg);
static void _ddekit_usb_thread();
static void device_connect_callback(struct ddekit_usb_dev * dev,
unsigned int interfaces);
char *_ddekit_usb_get_manufacturer(struct ddekit_usb_dev *ddev);
@@ -92,12 +92,12 @@ usb_interface_descriptor_t *_ddekit_usb_get_interface_desc(struct
ddekit_usb_dev *ddev, int inum);
PRIVATE ddekit_usb_malloc_fn my_malloc;
PRIVATE ddekit_usb_free_fn my_free;
PRIVATE struct minix_usb_driver gbl_drivers[MAX_DRIVERS];
PRIVATE struct minix_usb_device _devices[MAX_DEVS];
static ddekit_usb_malloc_fn my_malloc;
static ddekit_usb_free_fn my_free;
static struct minix_usb_driver gbl_drivers[MAX_DRIVERS];
static struct minix_usb_device _devices[MAX_DEVS];
PRIVATE struct ddekit_usb_driver my_driver = {
static struct ddekit_usb_driver my_driver = {
.completion = completion_callback,
.connect = device_connect_callback,
.disconnect = device_disconnect_callback,
@@ -107,7 +107,7 @@ PRIVATE struct ddekit_usb_driver my_driver = {
/*****************************************************************************
* find_driver *
****************************************************************************/
PRIVATE struct minix_usb_driver *find_driver(endpoint_t ep)
static struct minix_usb_driver *find_driver(endpoint_t ep)
{
int i;
for (i = 0; i < MAX_DRIVERS; i++ ){
@@ -121,7 +121,7 @@ PRIVATE struct minix_usb_driver *find_driver(endpoint_t ep)
/*****************************************************************************
* find_unused_driver *
****************************************************************************/
PRIVATE struct minix_usb_driver *find_unused_driver()
static struct minix_usb_driver *find_unused_driver()
{
int i;
for (i = 0; i < MAX_DRIVERS; i++ ){
@@ -135,7 +135,7 @@ PRIVATE struct minix_usb_driver *find_unused_driver()
/*****************************************************************************
* add_to_pending_urbs *
****************************************************************************/
PRIVATE int add_to_pending_urbs(struct minix_usb_driver *drv,
static int add_to_pending_urbs(struct minix_usb_driver *drv,
struct ddekit_usb_urb *urb)
{
int i;
@@ -153,7 +153,7 @@ PRIVATE int add_to_pending_urbs(struct minix_usb_driver *drv,
/*****************************************************************************
* remove_from_pending_urbs *
****************************************************************************/
PRIVATE int remove_from_pending_urbs(struct minix_usb_driver *drv,
static int remove_from_pending_urbs(struct minix_usb_driver *drv,
struct ddekit_usb_urb *urb)
{
int i;
@@ -171,7 +171,7 @@ PRIVATE int remove_from_pending_urbs(struct minix_usb_driver *drv,
/*****************************************************************************
* find_pending_urb *
****************************************************************************/
PRIVATE struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
static struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
unsigned urb_id)
{
int i;
@@ -188,7 +188,7 @@ PRIVATE struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
/*****************************************************************************
* register_driver *
****************************************************************************/
PRIVATE void register_driver(message *msg)
static void register_driver(message *msg)
{
endpoint_t ep = msg->m_source;
struct minix_usb_driver *drv;
@@ -222,7 +222,7 @@ PRIVATE void register_driver(message *msg)
/*****************************************************************************
* deregister_driver *
****************************************************************************/
PRIVATE void deregister_driver(message *msg)
static void deregister_driver(message *msg)
{
endpoint_t ep = msg->m_source;
@@ -245,7 +245,7 @@ PRIVATE void deregister_driver(message *msg)
/*****************************************************************************
* ddekit_usb_urb_from_mx_urb *
****************************************************************************/
PRIVATE struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb)
static struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb)
{
/*
* A helper function that generates (allocates and initializes)
@@ -284,7 +284,7 @@ PRIVATE struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb
/*****************************************************************************
* submit_urb *
****************************************************************************/
PRIVATE void submit_urb(message *msg)
static void submit_urb(message *msg)
{
/*
* submit_urb
@@ -410,7 +410,7 @@ out:
/*****************************************************************************
* cancle_urb *
****************************************************************************/
PRIVATE void cancle_urb(message *msg)
static void cancle_urb(message *msg)
{
endpoint_t ep = msg->m_source;
@@ -444,7 +444,7 @@ PRIVATE void cancle_urb(message *msg)
/*****************************************************************************
* completion_callback *
****************************************************************************/
PRIVATE void completion_callback(void *priv)
static void completion_callback(void *priv)
{
/*
* completion_callback
@@ -497,7 +497,7 @@ PRIVATE void completion_callback(void *priv)
/*****************************************************************************
* prepare_devman_usbdev *
****************************************************************************/
PRIVATE void prepare_devman_usbdev
static void prepare_devman_usbdev
(struct ddekit_usb_dev * dev, int dev_id, unsigned int interfaces,
struct devman_usb_dev *dudev)
{
@@ -531,7 +531,7 @@ PRIVATE void prepare_devman_usbdev
/*****************************************************************************
* device_connect_callback *
****************************************************************************/
PRIVATE void
static void
device_connect_callback
(struct ddekit_usb_dev * dev, unsigned int interfaces) {
@@ -574,7 +574,7 @@ device_connect_callback
/*****************************************************************************
* device_disconnect_callback *
****************************************************************************/
PRIVATE void device_disconnect_callback(struct ddekit_usb_dev * dev)
static void device_disconnect_callback(struct ddekit_usb_dev * dev)
{
int i;
@@ -616,7 +616,7 @@ PRIVATE void device_disconnect_callback(struct ddekit_usb_dev * dev)
/*****************************************************************************
* add_acl *
****************************************************************************/
PRIVATE int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
static int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
{
/*
* This functions binds a specific USB interface to a client.
@@ -657,7 +657,7 @@ PRIVATE int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
/*****************************************************************************
* del_acl *
****************************************************************************/
PRIVATE int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
static int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
{
struct minix_usb_driver *drv;
int dev, withdraw = 0;
@@ -692,7 +692,7 @@ PRIVATE int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
/*****************************************************************************
* handle_msg *
****************************************************************************/
PRIVATE int handle_msg(message *msg)
static int handle_msg(message *msg)
{
/*
* handle_msg
@@ -721,7 +721,7 @@ PRIVATE int handle_msg(message *msg)
/*****************************************************************************
* devman_tread *
****************************************************************************/
PRIVATE void devman_thread(void *unused)
static void devman_thread(void *unused)
{
struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(DEVMAN_BASE,
DEVMAN_BASE + 0xff);
@@ -736,7 +736,7 @@ PRIVATE void devman_thread(void *unused)
/*****************************************************************************
* _ddekit_usb_thread *
****************************************************************************/
PRIVATE void _ddekit_usb_thread(void * unused)
static void _ddekit_usb_thread(void * unused)
{
struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(USB_BASE,
USB_BASE + 0xff);
@@ -758,7 +758,7 @@ PRIVATE void _ddekit_usb_thread(void * unused)
/*****************************************************************************
* bind_cb *
****************************************************************************/
PRIVATE int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
static int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
{
if(data) {
return add_acl(data->dev_id, data->interface, ep);
@@ -771,7 +771,7 @@ PRIVATE int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
/*****************************************************************************
* unbind_cb *
****************************************************************************/
PRIVATE int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
static int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
{
if(data) {
return del_acl(data->dev_id, data->interface, ep);
@@ -784,7 +784,7 @@ PRIVATE int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
/*****************************************************************************
* ddekit_usb_server_init *
****************************************************************************/
PUBLIC void ddekit_usb_server_init()
void ddekit_usb_server_init()
{
int i;
/*

24
lib/libdevman/generic.c
View File

@@ -12,16 +12,16 @@
#include "local.h"
PRIVATE endpoint_t devman_ep;
static endpoint_t devman_ep;
FORWARD int save_string(char *buffer, char *src, size_t *offset);
static int save_string(char *buffer, char *src, size_t *offset);
PRIVATE TAILQ_HEAD(devlist_head, devman_dev) dev_list;
static TAILQ_HEAD(devlist_head, devman_dev) dev_list;
/****************************************************************************
* save_string *
***************************************************************************/
PRIVATE int save_string(char *buffer, char *src, size_t *offset)
static int save_string(char *buffer, char *src, size_t *offset)
{
unsigned old_offset = *offset;
size_t len = strlen(src) + 1;
@@ -33,7 +33,7 @@ PRIVATE int save_string(char *buffer, char *src, size_t *offset)
/****************************************************************************
* serialize_dev *
***************************************************************************/
PUBLIC void *serialize_dev(struct devman_dev *dev, size_t *overall_size)
void *serialize_dev(struct devman_dev *dev, size_t *overall_size)
{
/* determine size of serialized version of dev */
char *buffer;
@@ -99,7 +99,7 @@ PUBLIC void *serialize_dev(struct devman_dev *dev, size_t *overall_size)
/****************************************************************************
* devman_add_device *
***************************************************************************/
PUBLIC int devman_add_device(struct devman_dev *dev)
int devman_add_device(struct devman_dev *dev)
{
message msg;
int res;
@@ -148,7 +148,7 @@ PUBLIC int devman_add_device(struct devman_dev *dev)
/****************************************************************************
* devman_del_device *
***************************************************************************/
PUBLIC int devman_del_device(struct devman_dev *dev)
int devman_del_device(struct devman_dev *dev)
{
message msg;
int res;
@@ -182,7 +182,7 @@ PUBLIC int devman_del_device(struct devman_dev *dev)
/****************************************************************************
* devman_get_ep *
***************************************************************************/
PUBLIC endpoint_t devman_get_ep()
endpoint_t devman_get_ep()
{
return devman_ep;
}
@@ -190,7 +190,7 @@ PUBLIC endpoint_t devman_get_ep()
/****************************************************************************
* devman_init *
***************************************************************************/
PUBLIC int devman_init()
int devman_init()
{
int res;
@@ -209,7 +209,7 @@ PUBLIC int devman_init()
/****************************************************************************
* do_bind *
***************************************************************************/
PRIVATE void do_bind(message *m)
static void do_bind(message *m)
{
struct devman_dev *dev;
int res;
@@ -235,7 +235,7 @@ PRIVATE void do_bind(message *m)
/****************************************************************************
* do_unbind *
***************************************************************************/
PRIVATE void do_unbind(message *m)
static void do_unbind(message *m)
{
struct devman_dev *dev;
int res;
@@ -260,7 +260,7 @@ PRIVATE void do_unbind(message *m)
/****************************************************************************
* devman_handle_msg *
***************************************************************************/
PUBLIC int devman_handle_msg(message *m)
int devman_handle_msg(message *m)
{
/* make sure msg comes from devman server */
if (m->m_source != devman_ep) {

20
lib/libdevman/usb.c
View File

@@ -21,7 +21,7 @@ static int (*unbind_cb) (struct devman_usb_bind_cb_data *data, endpoint_t ep);
/****************************************************************************
* devman_usb_add_attr *
***************************************************************************/
PRIVATE void
static void
devman_usb_add_attr
(struct devman_dev *dev, char *name, char *data)
{
@@ -41,7 +41,7 @@ devman_usb_add_attr
/****************************************************************************
* add_device_attributes *
***************************************************************************/
PRIVATE void
static void
add_device_attributes
(struct devman_usb_dev *udev)
{
@@ -90,7 +90,7 @@ add_device_attributes
/****************************************************************************
* add_interface_attributes *
***************************************************************************/
PRIVATE void
static void
add_interface_attributes
(struct devman_usb_interface *intf)
{
@@ -140,7 +140,7 @@ add_interface_attributes
/****************************************************************************
* devman_usb_device_new *
***************************************************************************/
PUBLIC struct devman_usb_dev*
struct devman_usb_dev*
devman_usb_device_new
(int dev_id)
{
@@ -171,7 +171,7 @@ devman_usb_device_new
/****************************************************************************
* devman_usb_device_delete *
***************************************************************************/
PUBLIC void devman_usb_device_delete(struct devman_usb_dev *udev)
void devman_usb_device_delete(struct devman_usb_dev *udev)
{
int i;
struct devman_static_attribute *attr,*temp;
@@ -197,7 +197,7 @@ PUBLIC void devman_usb_device_delete(struct devman_usb_dev *udev)
free(udev);
}
PRIVATE int devman_usb_bind_cb(void *data, endpoint_t ep) {
static int devman_usb_bind_cb(void *data, endpoint_t ep) {
if (bind_cb) {
return bind_cb((struct devman_usb_bind_cb_data *) data, ep);
} else {
@@ -205,7 +205,7 @@ PRIVATE int devman_usb_bind_cb(void *data, endpoint_t ep) {
}
}
PRIVATE int devman_usb_unbind_cb(void *data, endpoint_t ep) {
static int devman_usb_unbind_cb(void *data, endpoint_t ep) {
if (unbind_cb) {
return unbind_cb((struct devman_usb_bind_cb_data *) data, ep);
} else {
@@ -216,7 +216,7 @@ PRIVATE int devman_usb_unbind_cb(void *data, endpoint_t ep) {
/****************************************************************************
* devman_usb_device_add *
***************************************************************************/
PUBLIC int devman_usb_device_add(struct devman_usb_dev *dev)
int devman_usb_device_add(struct devman_usb_dev *dev)
{
int i,res = 0;
add_device_attributes(dev);
@@ -273,7 +273,7 @@ PUBLIC int devman_usb_device_add(struct devman_usb_dev *dev)
/****************************************************************************
* devman_usb_device_remove *
***************************************************************************/
PUBLIC int devman_usb_device_remove(struct devman_usb_dev *dev)
int devman_usb_device_remove(struct devman_usb_dev *dev)
{
int i, res = 0;
@@ -292,7 +292,7 @@ PUBLIC int devman_usb_device_remove(struct devman_usb_dev *dev)
/****************************************************************************
* devman_usb_init *
***************************************************************************/
PUBLIC void devman_usb_init
void devman_usb_init
(int (*_bind_cb) (struct devman_usb_bind_cb_data *data, endpoint_t ep),
int (*_unbind_cb) (struct devman_usb_bind_cb_data *data, endpoint_t ep))
{

4
lib/libedit/editline.c
View File

@@ -81,8 +81,8 @@ STATIC int Point;
STATIC int PushBack;
STATIC int Pushed;
STATIC int Signal;
FORWARD KEYMAP Map[33];
FORWARD KEYMAP MetaMap[17];
static KEYMAP Map[33];
static KEYMAP MetaMap[17];
STATIC SIZE_T Length;
STATIC SIZE_T ScreenCount;
STATIC SIZE_T ScreenSize;

6
lib/libhgfs/attr.c
View File

@@ -7,7 +7,7 @@
/*===========================================================================*
* attr_get *
*===========================================================================*/
PUBLIC void attr_get(attr)
void attr_get(attr)
struct hgfs_attr *attr;
{
/* Get attribute information from the RPC buffer, storing the requested parts
@@ -35,7 +35,7 @@ struct hgfs_attr *attr;
/*===========================================================================*
* hgfs_getattr *
*===========================================================================*/
PUBLIC int hgfs_getattr(path, attr)
int hgfs_getattr(path, attr)
char *path;
struct hgfs_attr *attr;
{
@@ -58,7 +58,7 @@ struct hgfs_attr *attr;
/*===========================================================================*
* hgfs_setattr *
*===========================================================================*/
PUBLIC int hgfs_setattr(path, attr)
int hgfs_setattr(path, attr)
char *path;
struct hgfs_attr *attr;
{

8
lib/libhgfs/channel.c
View File

@@ -19,7 +19,7 @@ enum {
/*===========================================================================*
* channel_open *
*===========================================================================*/
PUBLIC int channel_open(ch, type)
int channel_open(ch, type)
struct channel *ch; /* struct describing the new channel */
u32_t type; /* channel type: CH_IN or CH_OUT */
{
@@ -46,7 +46,7 @@ u32_t type; /* channel type: CH_IN or CH_OUT */
/*===========================================================================*
* channel_close *
*===========================================================================*/
PUBLIC void channel_close(ch)
void channel_close(ch)
struct channel *ch; /* backdoor channel to close */
{
/* Close a previously opened backdoor channel.
@@ -64,7 +64,7 @@ struct channel *ch; /* backdoor channel to close */
/*===========================================================================*
* channel_send *
*===========================================================================*/
PUBLIC int channel_send(ch, buf, len)
int channel_send(ch, buf, len)
struct channel *ch; /* backdoor channel to send to */
char *buf; /* buffer to send data from */
int len; /* size of the data to send */
@@ -101,7 +101,7 @@ int len; /* size of the data to send */
/*===========================================================================*
* channel_recv *
*===========================================================================*/
PUBLIC int channel_recv(ch, buf, max)
int channel_recv(ch, buf, max)
struct channel *ch; /* backdoor channel to receive from */
char *buf; /* buffer to receive data into */
int max; /* size of the buffer */

6
lib/libhgfs/dir.c
View File

@@ -5,7 +5,7 @@
/*===========================================================================*
* hgfs_opendir *
*===========================================================================*/
PUBLIC int hgfs_opendir(path, handle)
int hgfs_opendir(path, handle)
char *path;
hgfs_dir_t *handle;
{
@@ -28,7 +28,7 @@ hgfs_dir_t *handle;
/*===========================================================================*
* hgfs_readdir *
*===========================================================================*/
PUBLIC int hgfs_readdir(handle, index, buf, size, attr)
int hgfs_readdir(handle, index, buf, size, attr)
hgfs_dir_t handle;
unsigned int index;
char *buf;
@@ -58,7 +58,7 @@ struct hgfs_attr *attr;
/*===========================================================================*
* hgfs_closedir *
*===========================================================================*/
PUBLIC int hgfs_closedir(handle)
int hgfs_closedir(handle)
hgfs_dir_t handle;
{
/* Close an open directory.

4
lib/libhgfs/error.c
View File

@@ -6,7 +6,7 @@
* that weren't in the original protocol, are being returned now.
*/
#define NERRS 16
PRIVATE int error_map[NERRS] = {
static int error_map[NERRS] = {
OK, /* no error */
ENOENT, /* no such file/directory */
EBADF, /* invalid handle */
@@ -28,7 +28,7 @@ PRIVATE int error_map[NERRS] = {
/*===========================================================================*
* error_convert *
*===========================================================================*/
PUBLIC int error_convert(err)
int error_convert(err)
int err;
{
/* Convert a HGFS error into an errno error code.

12
lib/libhgfs/file.c
View File

@@ -8,7 +8,7 @@
/*===========================================================================*
* hgfs_open *
*===========================================================================*/
PUBLIC int hgfs_open(path, flags, mode, handle)
int hgfs_open(path, flags, mode, handle)
char *path; /* path name to open */
int flags; /* open flags to use */
int mode; /* mode to create (user bits only) */
@@ -50,7 +50,7 @@ hgfs_file_t *handle; /* place to store resulting handle */
/*===========================================================================*
* hgfs_read *
*===========================================================================*/
PUBLIC int hgfs_read(handle, buf, size, off)
int hgfs_read(handle, buf, size, off)
hgfs_file_t handle; /* handle to open file */
char *buf; /* data buffer or NULL */
size_t size; /* maximum number of bytes to read */
@@ -84,7 +84,7 @@ u64_t off; /* file offset */
/*===========================================================================*
* hgfs_write *
*===========================================================================*/
PUBLIC int hgfs_write(handle, buf, len, off, append)
int hgfs_write(handle, buf, len, off, append)
hgfs_file_t handle; /* handle to open file */
const char *buf; /* data buffer or NULL */
size_t len; /* number of bytes to write */
@@ -125,7 +125,7 @@ int append; /* if set, append to file (ignore offset) */
/*===========================================================================*
* hgfs_close *
*===========================================================================*/
PUBLIC int hgfs_close(handle)
int hgfs_close(handle)
hgfs_file_t handle; /* handle to open file */
{
/* Close an open file.
@@ -140,7 +140,7 @@ hgfs_file_t handle; /* handle to open file */
/*===========================================================================*
* hgfs_readbuf *
*===========================================================================*/
PUBLIC size_t hgfs_readbuf(ptr)
size_t hgfs_readbuf(ptr)
char **ptr;
{
/* Return information about the read buffer, for zero-copy purposes. Store a
@@ -162,7 +162,7 @@ char **ptr;
/*===========================================================================*
* hgfs_writebuf *
*===========================================================================*/
PUBLIC size_t hgfs_writebuf(ptr)
size_t hgfs_writebuf(ptr)
char **ptr;
{
/* Return information about the write buffer, for zero-copy purposes. Store a

8
lib/libhgfs/link.c
View File

@@ -7,7 +7,7 @@
/*===========================================================================*
* hgfs_mkdir *
*===========================================================================*/
PUBLIC int hgfs_mkdir(path, mode)
int hgfs_mkdir(path, mode)
char *path;
int mode;
{
@@ -25,7 +25,7 @@ int mode;
/*===========================================================================*
* hgfs_unlink *
*===========================================================================*/
PUBLIC int hgfs_unlink(path)
int hgfs_unlink(path)
char *path;
{
/* Delete a file.
@@ -41,7 +41,7 @@ char *path;
/*===========================================================================*
* hgfs_rmdir *
*===========================================================================*/
PUBLIC int hgfs_rmdir(path)
int hgfs_rmdir(path)
char *path;
{
/* Remove an empty directory.
@@ -57,7 +57,7 @@ char *path;
/*===========================================================================*
* hgfs_rename *
*===========================================================================*/
PUBLIC int hgfs_rename(opath, npath)
int hgfs_rename(opath, npath)
char *opath;
char *npath;
{

8
lib/libhgfs/misc.c
View File

@@ -5,7 +5,7 @@
/*===========================================================================*
* hgfs_init *
*===========================================================================*/
PUBLIC int hgfs_init()
int hgfs_init()
{
/* Initialize the library. Return OK on success, or a negative error code
* otherwise. If EAGAIN is returned, shared folders are disabled; in that
@@ -20,7 +20,7 @@ PUBLIC int hgfs_init()
/*===========================================================================*
* hgfs_cleanup *
*===========================================================================*/
PUBLIC void hgfs_cleanup()
void hgfs_cleanup()
{
/* Clean up state.
*/
@@ -31,7 +31,7 @@ PUBLIC void hgfs_cleanup()
/*===========================================================================*
* hgfs_enabled *
*===========================================================================*/
PUBLIC int hgfs_enabled()
int hgfs_enabled()
{
/* Check if shared folders are enabled. Return OK if so, EAGAIN if not, and
* another negative error code on error.
@@ -43,7 +43,7 @@ PUBLIC int hgfs_enabled()
/*===========================================================================*
* hgfs_queryvol *
*===========================================================================*/
PUBLIC int hgfs_queryvol(path, free, total)
int hgfs_queryvol(path, free, total)
char *path;
u64_t *free;
u64_t *total;

4
lib/libhgfs/path.c
View File

@@ -7,7 +7,7 @@
/*===========================================================================*
* path_put *
*===========================================================================*/
PUBLIC void path_put(path)
void path_put(path)
char *path;
{
/* Append the given path name in HGFS format to the RPC buffer. Truncate it
@@ -42,7 +42,7 @@ char *path;
/*===========================================================================*
* path_get *
*===========================================================================*/
PUBLIC int path_get(path, max)
int path_get(path, max)
char *path;
int max;
{

14
lib/libhgfs/rpc.c
View File

@@ -2,15 +2,15 @@
#include "inc.h"
PUBLIC char rpc_buf[RPC_BUF_SIZE];
PUBLIC char *rpc_ptr;
char rpc_buf[RPC_BUF_SIZE];
char *rpc_ptr;
PRIVATE struct channel rpc_chan;
static struct channel rpc_chan;
/*===========================================================================*
* rpc_open *
*===========================================================================*/
PUBLIC int rpc_open()
int rpc_open()
{
/* Open a HGFS RPC backdoor channel to the VMware host, and make sure that it
* is working. Return OK upon success, or a negative error code otherwise.
@@ -31,7 +31,7 @@ PUBLIC int rpc_open()
/*===========================================================================*
* rpc_query *
*===========================================================================*/
PUBLIC int rpc_query()
int rpc_query()
{
/* Send a HGFS RPC query over the backdoor channel. Return OK upon success, or
* a negative error code otherwise; EAGAIN is returned if shared folders are
@@ -69,7 +69,7 @@ PUBLIC int rpc_query()
/*===========================================================================*
* rpc_test *
*===========================================================================*/
PUBLIC int rpc_test()
int rpc_test()
{
/* Test whether HGFS communication is working. Return OK on success, EAGAIN if
* shared folders are disabled, or another negative error code upon error.
@@ -85,7 +85,7 @@ PUBLIC int rpc_test()
/*===========================================================================*
* rpc_close *
*===========================================================================*/
PUBLIC void rpc_close()
void rpc_close()
{
/* Close the HGFS RPC backdoor channel.
*/

8
lib/libhgfs/time.c
View File

@@ -2,12 +2,12 @@
#include "inc.h"
PRIVATE u64_t time_offset;
static u64_t time_offset;
/*===========================================================================*
* time_init *
*===========================================================================*/
PUBLIC void time_init()
void time_init()
{
/* Initialize the time conversion module.
*/
@@ -24,7 +24,7 @@ PUBLIC void time_init()
/*===========================================================================*
* time_put *
*===========================================================================*/
PUBLIC void time_put(timep)
void time_put(timep)
time_t *timep;
{
/* Store a UNIX timestamp pointed to by the given pointer onto the RPC buffer,
@@ -47,7 +47,7 @@ time_t *timep;
/*===========================================================================*
* time_get *
*===========================================================================*/
PUBLIC void time_get(timep)
void time_get(timep)
time_t *timep;
{
/* Get a HGFS timestamp from the RPC buffer, convert it into a UNIX timestamp,

12
lib/libminlib/fslib.c
View File

@@ -31,7 +31,7 @@
* unlikely, but negative bit counts are now possible (though unlikely)
* and give silly results.
*/
PUBLIC int bitmapsize(nr_bits, block_size)
int bitmapsize(nr_bits, block_size)
bit_t nr_bits;
int block_size;
{
@@ -46,7 +46,7 @@ int block_size;
/*===========================================================================*
* conv2 *
*===========================================================================*/
PUBLIC unsigned conv2(norm, w)
unsigned conv2(norm, w)
int norm; /* TRUE if no swap, FALSE for byte swap */
int w; /* promotion of 16-bit word to be swapped */
{
@@ -60,7 +60,7 @@ int w; /* promotion of 16-bit word to be swapped */
/*===========================================================================*
* conv4 *
*===========================================================================*/
PUBLIC long conv4(norm, x)
long conv4(norm, x)
int norm; /* TRUE if no swap, FALSE for byte swap */
long x; /* 32-bit long to be byte swapped */
{
@@ -80,7 +80,7 @@ long x; /* 32-bit long to be byte swapped */
/*===========================================================================*
* conv_inode *
*===========================================================================*/
PUBLIC void conv_inode(rip, dip, dip2, rw_flag, magic)
void conv_inode(rip, dip, dip2, rw_flag, magic)
register struct inode *rip; /* pointer to the in-core inode struct */
register d1_inode *dip; /* pointer to the V1 on-disk inode struct */
register d2_inode *dip2; /* pointer to the V2 on-disk inode struct */
@@ -103,7 +103,7 @@ int magic; /* magic number of file system */
/*===========================================================================*
* old_icopy *
*===========================================================================*/
PUBLIC void old_icopy(rip, dip, direction, norm)
void old_icopy(rip, dip, direction, norm)
register struct inode *rip; /* pointer to the in-core inode struct */
register d1_inode *dip; /* pointer to the d1_inode inode struct */
int direction; /* READING (from disk) or WRITING (to disk) */
@@ -150,7 +150,7 @@ int norm; /* TRUE = do not swap bytes; FALSE = swap */
/*===========================================================================*
* new_icopy *
*===========================================================================*/
PUBLIC void new_icopy(rip, dip, direction, norm)
void new_icopy(rip, dip, direction, norm)
register struct inode *rip; /* pointer to the in-core inode struct */
register d2_inode *dip; /* pointer to the d2_inode struct */
int direction; /* READING (from disk) or WRITING (to disk) */

2
lib/libminlib/getngid.c
View File

@@ -1,7 +1,7 @@
#include <lib.h>
#include <unistd.h>
PUBLIC gid_t getngid(endpoint_t proc_ep)
gid_t getngid(endpoint_t proc_ep)
{
message m;
m.m1_i1 = proc_ep; /* search gid for this process */

2
lib/libminlib/getnpid.c
View File

@@ -1,7 +1,7 @@
#include <lib.h>
#include <unistd.h>
PUBLIC pid_t getnpid(endpoint_t proc_ep)
pid_t getnpid(endpoint_t proc_ep)
{
message m;
m.m1_i1 = proc_ep; /* search pid for this process */

2
lib/libminlib/getnprocnr.c
View File

@@ -2,7 +2,7 @@
#include <unistd.h>
PUBLIC int getnprocnr(pid_t pid)
int getnprocnr(pid_t pid)
{
message m;
int t = GETPROCNR;

2
lib/libminlib/getnucred.c
View File

@@ -3,7 +3,7 @@
#include <sys/ucred.h>
#include <unistd.h>
PUBLIC int getnucred(endpoint_t proc_ep, struct ucred *ucred)
int getnucred(endpoint_t proc_ep, struct ucred *ucred)
{
message m;
pid_t pid;

2
lib/libminlib/getnuid.c
View File

@@ -1,7 +1,7 @@
#include <lib.h>
#include <unistd.h>
PUBLIC uid_t getnuid(endpoint_t proc_ep)
uid_t getnuid(endpoint_t proc_ep)
{
message m;
m.m1_i1 = proc_ep; /* search uid for this process */

2
lib/libminlib/getprocnr.c
View File

@@ -2,7 +2,7 @@
#include <unistd.h>
PUBLIC int getprocnr()
int getprocnr()
{
message m;
m.m1_i1 = -1; /* don't pass pid to search for */

4
lib/libminlib/itoa.c
View File

@@ -1,8 +1,8 @@
#include <lib.h>
/* Integer to ASCII for signed decimal integers. */
PRIVATE int next;
PRIVATE char qbuf[8];
static int next;
static char qbuf[8];
char *itoa(int n);

2
lib/libminlib/mapdriver.c
View File

@@ -3,7 +3,7 @@
#include <unistd.h>
PUBLIC int mapdriver(label, major, dev_style, flags)
int mapdriver(label, major, dev_style, flags)
char *label;
int major;
int dev_style;

2
lib/libminlib/vm_memctl.c
View File

@@ -1,7 +1,7 @@
#include <lib.h>
#include <unistd.h>
PUBLIC int vm_memctl(endpoint_t ep, int req)
int vm_memctl(endpoint_t ep, int req)
{
message m;
m.VM_RS_CTL_ENDPT = ep;

4
lib/libminlib/vm_query_exit.c
View File

@@ -8,7 +8,7 @@
* return 0, when there are no more processes.
* note that for the return value of 0 and 1, the 'endpt' is set accordingly.
*/
PUBLIC int vm_query_exit(int *endpt)
int vm_query_exit(int *endpt)
{
message m;
int r;
@@ -23,7 +23,7 @@ PUBLIC int vm_query_exit(int *endpt)
return (m.VM_QUERY_IS_MORE ? 1 : 0);
}
PUBLIC int vm_watch_exit(endpoint_t ep)
int vm_watch_exit(endpoint_t ep)
{
message m;

2
lib/libminlib/vm_set_priv.c
View File

@@ -1,7 +1,7 @@
#include <lib.h>
#include <unistd.h>
PUBLIC int vm_set_priv(int nr, void *buf)
int vm_set_priv(int nr, void *buf)
{
message m;
m.VM_RS_NR = nr;

2
lib/libminlib/vm_update.c
View File

@@ -1,7 +1,7 @@
#include <lib.h>
#include <unistd.h>
PUBLIC int vm_update(endpoint_t src_e, endpoint_t dst_e)
int vm_update(endpoint_t src_e, endpoint_t dst_e)
{
message m;
m.VM_RS_SRC_ENDPT = src_e;

40
lib/libmthread/allocate.c
View File

@@ -7,20 +7,20 @@
#include "global.h"
#include "proto.h"
FORWARD int mthread_increase_thread_pool(void);
FORWARD void mthread_thread_init(mthread_thread_t thread, mthread_attr_t
static int mthread_increase_thread_pool(void);
static void mthread_thread_init(mthread_thread_t thread, mthread_attr_t
*tattr, void *(*proc)(void *), void *arg);
FORWARD void mthread_thread_stop(mthread_thread_t thread);
FORWARD void mthread_trampoline(void);
static void mthread_thread_stop(mthread_thread_t thread);
static void mthread_trampoline(void);
PRIVATE int initialized = 0;
static int initialized = 0;
#ifndef PGSHIFT
# define PGSHIFT 12 /* XXX: temporarily for ACK */
#endif
#define MTHREAD_GUARDSIZE (1 << PGSHIFT) /* 1 page */
PRIVATE struct __mthread_attr default_attr = { MTHREAD_STACK_MIN,
static struct __mthread_attr default_attr = { MTHREAD_STACK_MIN,
NULL,
MTHREAD_CREATE_JOINABLE,
NULL, NULL };
@@ -28,7 +28,7 @@ PRIVATE struct __mthread_attr default_attr = { MTHREAD_STACK_MIN,
/*===========================================================================*
* mthread_equal *
*===========================================================================*/
PUBLIC int mthread_equal(l, r)
int mthread_equal(l, r)
mthread_thread_t l;
mthread_thread_t r;
{
@@ -42,7 +42,7 @@ mthread_thread_t r;
/*===========================================================================*
* mthread_create *
*===========================================================================*/
PUBLIC int mthread_create(threadid, tattr, proc, arg)
int mthread_create(threadid, tattr, proc, arg)
mthread_thread_t *threadid;
mthread_attr_t *tattr;
void *(*proc)(void *);
@@ -78,7 +78,7 @@ void *arg;
/*===========================================================================*
* mthread_detach *
*===========================================================================*/
PUBLIC int mthread_detach(detach)
int mthread_detach(detach)
mthread_thread_t detach;
{
/* Mark a thread as detached. Consequently, upon exit, resources allocated for
@@ -107,7 +107,7 @@ mthread_thread_t detach;
/*===========================================================================*
* mthread_exit *
*===========================================================================*/
PUBLIC void mthread_exit(value)
void mthread_exit(value)
void *value;
{
/* Make a thread stop running and store the result value. */
@@ -143,7 +143,7 @@ void *value;
/*===========================================================================*
* mthread_find_tcb *
*===========================================================================*/
PUBLIC mthread_tcb_t * mthread_find_tcb(thread)
mthread_tcb_t * mthread_find_tcb(thread)
mthread_thread_t thread;
{
mthread_tcb_t *rt = NULL;
@@ -162,7 +162,7 @@ mthread_thread_t thread;
/*===========================================================================*
* mthread_increase_thread_pool *
*===========================================================================*/
PRIVATE int mthread_increase_thread_pool(void)
static int mthread_increase_thread_pool(void)
{
/* Increase thread pool. No fancy algorithms, just double the size. */
mthread_tcb_t **new_tcb;
@@ -223,7 +223,7 @@ PRIVATE int mthread_increase_thread_pool(void)
/*===========================================================================*
* mthread_init *
*===========================================================================*/
PUBLIC void mthread_init(void)
void mthread_init(void)
{
/* Initialize thread system; allocate thread structures and start creating
* threads.
@@ -256,7 +256,7 @@ PUBLIC void mthread_init(void)
/*===========================================================================*
* mthread_join *
*===========================================================================*/
PUBLIC int mthread_join(join, value)
int mthread_join(join, value)
mthread_thread_t join;
void **value;
{
@@ -314,7 +314,7 @@ void **value;
/*===========================================================================*
* mthread_once *
*===========================================================================*/
PUBLIC int mthread_once(once, proc)
int mthread_once(once, proc)
mthread_once_t *once;
void (*proc)(void);
{
@@ -334,7 +334,7 @@ void (*proc)(void);
/*===========================================================================*
* mthread_self *
*===========================================================================*/
PUBLIC mthread_thread_t mthread_self(void)
mthread_thread_t mthread_self(void)
{
/* Return the thread id of the thread calling this function. */
@@ -347,7 +347,7 @@ PUBLIC mthread_thread_t mthread_self(void)
/*===========================================================================*
* mthread_thread_init *
*===========================================================================*/
PRIVATE void mthread_thread_init(thread, tattr, proc, arg)
static void mthread_thread_init(thread, tattr, proc, arg)
mthread_thread_t thread;
mthread_attr_t *tattr;
void *(*proc)(void *);
@@ -447,7 +447,7 @@ void *arg;
/*===========================================================================*
* mthread_thread_reset *
*===========================================================================*/
PUBLIC void mthread_thread_reset(thread)
void mthread_thread_reset(thread)
mthread_thread_t thread;
{
/* Reset the thread to its default values. Free the allocated stack space. */
@@ -480,7 +480,7 @@ mthread_thread_t thread;
/*===========================================================================*
* mthread_thread_stop *
*===========================================================================*/
PRIVATE void mthread_thread_stop(thread)
static void mthread_thread_stop(thread)
mthread_thread_t thread;
{
/* Stop thread from running. Deallocate resources. */
@@ -513,7 +513,7 @@ mthread_thread_t thread;
/*===========================================================================*
* mthread_trampoline *
*===========================================================================*/
PRIVATE void mthread_trampoline(void)
static void mthread_trampoline(void)
{
/* Execute the /current_thread's/ procedure. Store its result. */

34
lib/libmthread/attribute.c
View File

@@ -2,15 +2,15 @@
#include "global.h"
#include "proto.h"
PRIVATE struct __mthread_attr *va_front, *va_rear;
FORWARD void mthread_attr_add(mthread_attr_t *a);
FORWARD void mthread_attr_remove(mthread_attr_t *a);
FORWARD int mthread_attr_valid(mthread_attr_t *a);
static struct __mthread_attr *va_front, *va_rear;
static void mthread_attr_add(mthread_attr_t *a);
static void mthread_attr_remove(mthread_attr_t *a);
static int mthread_attr_valid(mthread_attr_t *a);
/*===========================================================================*
* mthread_init_valid_attributes *
*===========================================================================*/
PUBLIC void mthread_init_valid_attributes(void)
void mthread_init_valid_attributes(void)
{
/* Initialize list of valid attributs */
va_front = va_rear = NULL;
@@ -20,7 +20,7 @@ PUBLIC void mthread_init_valid_attributes(void)
/*===========================================================================*
* mthread_attr_add *
*===========================================================================*/
PRIVATE void mthread_attr_add(a)
static void mthread_attr_add(a)
mthread_attr_t *a;
{
/* Add attribute to list of valid, initialized attributes */
@@ -41,7 +41,7 @@ mthread_attr_t *a;
/*===========================================================================*
* mthread_attr_destroy *
*===========================================================================*/
PUBLIC int mthread_attr_destroy(attr)
int mthread_attr_destroy(attr)
mthread_attr_t *attr;
{
/* Invalidate attribute and deallocate resources. */
@@ -66,7 +66,7 @@ mthread_attr_t *attr;
/*===========================================================================*
* mthread_attr_init *
*===========================================================================*/
PUBLIC int mthread_attr_init(attr)
int mthread_attr_init(attr)
mthread_attr_t *attr; /* Attribute */
{
/* Initialize the attribute to a known state. */
@@ -95,7 +95,7 @@ mthread_attr_t *attr; /* Attribute */
/*===========================================================================*
* mthread_attr_getdetachstate *
*===========================================================================*/
PUBLIC int mthread_attr_getdetachstate(attr, detachstate)
int mthread_attr_getdetachstate(attr, detachstate)
mthread_attr_t *attr;
int *detachstate;
{
@@ -120,7 +120,7 @@ int *detachstate;
/*===========================================================================*
* mthread_attr_setdetachstate *
*===========================================================================*/
PUBLIC int mthread_attr_setdetachstate(attr, detachstate)
int mthread_attr_setdetachstate(attr, detachstate)
mthread_attr_t *attr;
int detachstate;
{
@@ -148,7 +148,7 @@ int detachstate;
/*===========================================================================*
* mthread_attr_getstack *
*===========================================================================*/
PUBLIC int mthread_attr_getstack(attr, stackaddr, stacksize)
int mthread_attr_getstack(attr, stackaddr, stacksize)
mthread_attr_t *attr;
void **stackaddr;
size_t *stacksize;
@@ -175,7 +175,7 @@ size_t *stacksize;
/*===========================================================================*
* mthread_attr_getstacksize *
*===========================================================================*/
PUBLIC int mthread_attr_getstacksize(attr, stacksize)
int mthread_attr_getstacksize(attr, stacksize)
mthread_attr_t *attr;
size_t *stacksize;
{
@@ -200,7 +200,7 @@ size_t *stacksize;
/*===========================================================================*
* mthread_attr_setstack *
*===========================================================================*/
PUBLIC int mthread_attr_setstack(attr, stackaddr, stacksize)
int mthread_attr_setstack(attr, stackaddr, stacksize)
mthread_attr_t *attr;
void *stackaddr;
size_t stacksize;
@@ -232,7 +232,7 @@ size_t stacksize;
/*===========================================================================*
* mthread_attr_setstacksize *
*===========================================================================*/
PUBLIC int mthread_attr_setstacksize(attr, stacksize)
int mthread_attr_setstacksize(attr, stacksize)
mthread_attr_t *attr;
size_t stacksize;
{
@@ -257,7 +257,7 @@ size_t stacksize;
/*===========================================================================*
* mthread_attr_remove *
*===========================================================================*/
PRIVATE void mthread_attr_remove(a)
static void mthread_attr_remove(a)
mthread_attr_t *a;
{
/* Remove attribute from list of valid, initialized attributes */
@@ -277,7 +277,7 @@ mthread_attr_t *a;
/*===========================================================================*
* mthread_attr_valid *
*===========================================================================*/
PRIVATE int mthread_attr_valid(a)
static int mthread_attr_valid(a)
mthread_attr_t *a;
{
/* Check to see if attribute is on the list of valid attributes */
@@ -302,7 +302,7 @@ mthread_attr_t *a;
* mthread_attr_verify *
*===========================================================================*/
#ifdef MDEBUG
PUBLIC int mthread_attr_verify(void)
int mthread_attr_verify(void)
{
/* Return true when no attributes are in use */
struct __mthread_attr *loopitem;

28
lib/libmthread/condition.c
View File

@@ -3,10 +3,10 @@
#include "proto.h"
#ifdef MTHREAD_STRICT
PRIVATE struct __mthread_cond *vc_front, *vc_rear;
FORWARD void mthread_cond_add(mthread_cond_t *c);
FORWARD void mthread_cond_remove(mthread_cond_t *c);
FORWARD int mthread_cond_valid(mthread_cond_t *c);
static struct __mthread_cond *vc_front, *vc_rear;
static void mthread_cond_add(mthread_cond_t *c);
static void mthread_cond_remove(mthread_cond_t *c);
static int mthread_cond_valid(mthread_cond_t *c);
#else
# define mthread_cond_add(c) ((*c)->mc_magic = MTHREAD_INIT_MAGIC)
# define mthread_cond_remove(c) ((*c)->mc_magic = MTHREAD_NOT_INUSE)
@@ -17,7 +17,7 @@ FORWARD int mthread_cond_valid(mthread_cond_t *c);
/*===========================================================================*
* mthread_init_valid_conditions *
*===========================================================================*/
PUBLIC void mthread_init_valid_conditions(void)
void mthread_init_valid_conditions(void)
{
#ifdef MTHREAD_STRICT
/* Initialize condition variable list */
@@ -30,7 +30,7 @@ PUBLIC void mthread_init_valid_conditions(void)
* mthread_cond_add *
*===========================================================================*/
#ifdef MTHREAD_STRICT
PRIVATE void mthread_cond_add(c)
static void mthread_cond_add(c)
mthread_cond_t *c;
{
/* Add condition to list of valid, initialized conditions */
@@ -51,7 +51,7 @@ mthread_cond_t *c;
/*===========================================================================*
* mthread_cond_broadcast *
*===========================================================================*/
PUBLIC int mthread_cond_broadcast(cond)
int mthread_cond_broadcast(cond)
mthread_cond_t *cond;
{
/* Signal all threads waiting for condition 'cond'. */
@@ -82,7 +82,7 @@ mthread_cond_t *cond;
/*===========================================================================*
* mthread_cond_destroy *
*===========================================================================*/
PUBLIC int mthread_cond_destroy(cond)
int mthread_cond_destroy(cond)
mthread_cond_t *cond;
{
/* Destroy a condition variable. Make sure it's not in use */
@@ -119,7 +119,7 @@ mthread_cond_t *cond;
/*===========================================================================*
* mthread_cond_init *
*===========================================================================*/
PUBLIC int mthread_cond_init(cond, cattr)
int mthread_cond_init(cond, cattr)
mthread_cond_t *cond;
mthread_condattr_t *cattr;
{
@@ -153,7 +153,7 @@ mthread_condattr_t *cattr;
* mthread_cond_remove *
*===========================================================================*/
#ifdef MTHREAD_STRICT
PRIVATE void mthread_cond_remove(c)
static void mthread_cond_remove(c)
mthread_cond_t *c;
{
/* Remove condition from list of valid, initialized conditions */
@@ -174,7 +174,7 @@ mthread_cond_t *c;
/*===========================================================================*
* mthread_cond_signal *
*===========================================================================*/
PUBLIC int mthread_cond_signal(cond)
int mthread_cond_signal(cond)
mthread_cond_t *cond;
{
/* Signal a thread that condition 'cond' was met. Just a single thread. */
@@ -208,7 +208,7 @@ mthread_cond_t *cond;
* mthread_cond_valid *
*===========================================================================*/
#ifdef MTHREAD_STRICT
PRIVATE int mthread_cond_valid(c)
static int mthread_cond_valid(c)
mthread_cond_t *c;
{
/* Check to see if cond is on the list of valid conditions */
@@ -233,7 +233,7 @@ mthread_cond_t *c;
* mthread_cond_verify *
*===========================================================================*/
#ifdef MDEBUG
PUBLIC int mthread_cond_verify(void)
int mthread_cond_verify(void)
{
/* Return true in case no condition variables are in use. */
@@ -247,7 +247,7 @@ PUBLIC int mthread_cond_verify(void)
/*===========================================================================*
* mthread_cond_wait *
*===========================================================================*/
PUBLIC int mthread_cond_wait(cond, mutex)
int mthread_cond_wait(cond, mutex)
mthread_cond_t *cond;
mthread_mutex_t *mutex;
{

Some files were not shown because too many files have changed in this diff Show More