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

10
servers/pfs/buffer.c
View File

@@ -5,12 +5,12 @@
#include <stdlib.h>
#include <string.h>
FORWARD struct buf *new_block(dev_t dev, ino_t inum);
static struct buf *new_block(dev_t dev, ino_t inum);
/*===========================================================================*
* buf_pool *
*===========================================================================*/
PUBLIC void buf_pool(void)
void buf_pool(void)
{
/* Initialize the buffer pool. */
@@ -23,7 +23,7 @@ PUBLIC void buf_pool(void)
/*===========================================================================*
* get_block *
*===========================================================================*/
PUBLIC struct buf *get_block(dev_t dev, ino_t inum)
struct buf *get_block(dev_t dev, ino_t inum)
{
struct buf *bp = front;
@@ -43,7 +43,7 @@ PUBLIC struct buf *get_block(dev_t dev, ino_t inum)
/*===========================================================================*
* new_block *
*===========================================================================*/
PRIVATE struct buf *new_block(dev_t dev, ino_t inum)
static struct buf *new_block(dev_t dev, ino_t inum)
{
/* Allocate a new buffer and add it to the double linked buffer list */
struct buf *bp;
@@ -77,7 +77,7 @@ PRIVATE struct buf *new_block(dev_t dev, ino_t inum)
/*===========================================================================*
* put_block *
*===========================================================================*/
PUBLIC void put_block(dev_t dev, ino_t inum)
void put_block(dev_t dev, ino_t inum)
{
struct buf *bp;

24
servers/pfs/dev_uds.c
View File

@@ -32,12 +32,12 @@
#include "glo.h"
#include "uds.h"
FORWARD int uds_perform_read(int minor, endpoint_t m_source, size_t
static int uds_perform_read(int minor, endpoint_t m_source, size_t
size, int pretend);
FORWARD int uds_perform_write(int minor, endpoint_t m_source, size_t
static int uds_perform_write(int minor, endpoint_t m_source, size_t
size, int pretend);
PUBLIC int uds_open(message *dev_m_in, message *dev_m_out)
int uds_open(message *dev_m_in, message *dev_m_out)
{
message fs_m_in, fs_m_out;
struct ucred ucred;
@@ -206,7 +206,7 @@ PUBLIC int uds_open(message *dev_m_in, message *dev_m_out)
return minor;
}
PUBLIC int uds_close(message *dev_m_in, message *dev_m_out)
int uds_close(message *dev_m_in, message *dev_m_out)
{
int minor;
message fs_m_in, fs_m_out;
@@ -280,7 +280,7 @@ PUBLIC int uds_close(message *dev_m_in, message *dev_m_out)
return OK;
}
PUBLIC int uds_select(message *dev_m_in, message *dev_m_out)
int uds_select(message *dev_m_in, message *dev_m_out)
{
int i, bytes;
int minor;
@@ -349,7 +349,7 @@ PUBLIC int uds_select(message *dev_m_in, message *dev_m_out)
return uds_fd_table[minor].sel_ops_out;
}
PRIVATE int uds_perform_read(int minor, endpoint_t m_source,
static int uds_perform_read(int minor, endpoint_t m_source,
size_t size, int pretend)
{
int rc;
@@ -482,7 +482,7 @@ PRIVATE int uds_perform_read(int minor, endpoint_t m_source,
return fs_m_out.RES_NBYTES; /* return number of bytes read */
}
PRIVATE int uds_perform_write(int minor, endpoint_t m_source,
static int uds_perform_write(int minor, endpoint_t m_source,
size_t size, int pretend)
{
int rc, peer, i;
@@ -648,7 +648,7 @@ PRIVATE int uds_perform_write(int minor, endpoint_t m_source,
return fs_m_out.RES_NBYTES; /* return number of bytes written */
}
PUBLIC int uds_read(message *dev_m_in, message *dev_m_out)
int uds_read(message *dev_m_in, message *dev_m_out)
{
int bytes;
int minor;
@@ -698,7 +698,7 @@ PUBLIC int uds_read(message *dev_m_in, message *dev_m_out)
return bytes;
}
PUBLIC int uds_write(message *dev_m_in, message *dev_m_out)
int uds_write(message *dev_m_in, message *dev_m_out)
{
int bytes;
int minor;
@@ -748,7 +748,7 @@ PUBLIC int uds_write(message *dev_m_in, message *dev_m_out)
return bytes;
}
PUBLIC int uds_ioctl(message *dev_m_in, message *dev_m_out)
int uds_ioctl(message *dev_m_in, message *dev_m_out)
{
int rc, minor;
@@ -960,7 +960,7 @@ PUBLIC int uds_ioctl(message *dev_m_in, message *dev_m_out)
return rc;
}
PUBLIC int uds_unsuspend(endpoint_t m_source, int minor)
int uds_unsuspend(endpoint_t m_source, int minor)
{
int r = OK, bytes;
message m_out;
@@ -1044,7 +1044,7 @@ PUBLIC int uds_unsuspend(endpoint_t m_source, int minor)
return(r);
}
PUBLIC int uds_cancel(message *dev_m_in, message *dev_m_out)
int uds_cancel(message *dev_m_in, message *dev_m_out)
{
int i, j;
int minor;

26
servers/pfs/inode.c
View File

@@ -19,14 +19,14 @@
#include "inode.h"
#include <minix/vfsif.h>
FORWARD void addhash_inode(struct inode * const node);
FORWARD void unhash_inode(struct inode * const node);
static void addhash_inode(struct inode * const node);
static void unhash_inode(struct inode * const node);
/*===========================================================================*
* fs_putnode *
*===========================================================================*/
PUBLIC int fs_putnode(message *fs_m_in, message *fs_m_out)
int fs_putnode(message *fs_m_in, message *fs_m_out)
{
/* Find the inode specified by the request message and decrease its counter.*/
@@ -68,7 +68,7 @@ PUBLIC int fs_putnode(message *fs_m_in, message *fs_m_out)
/*===========================================================================*
* init_inode_cache *
*===========================================================================*/
PUBLIC void init_inode_cache()
void init_inode_cache()
{
struct inode *rip;
struct inodelist *rlp;
@@ -95,7 +95,7 @@ PUBLIC void init_inode_cache()
/*===========================================================================*
* addhash_inode *
*===========================================================================*/
PRIVATE void addhash_inode(struct inode * const node)
static void addhash_inode(struct inode * const node)
{
int hashi = (int) (node->i_num & INODE_HASH_MASK);
@@ -107,7 +107,7 @@ PRIVATE void addhash_inode(struct inode * const node)
/*===========================================================================*
* unhash_inode *
*===========================================================================*/
PRIVATE void unhash_inode(struct inode * const node)
static void unhash_inode(struct inode * const node)
{
/* remove from hash table */
LIST_REMOVE(node, i_hash);
@@ -117,7 +117,7 @@ PRIVATE void unhash_inode(struct inode * const node)
/*===========================================================================*
* get_inode *
*===========================================================================*/
PUBLIC struct inode *get_inode(
struct inode *get_inode(
dev_t dev, /* device on which inode resides */
ino_t numb /* inode number */
)
@@ -173,7 +173,7 @@ PUBLIC struct inode *get_inode(
/*===========================================================================*
* find_inode *
*===========================================================================*/
PUBLIC struct inode *find_inode(numb)
struct inode *find_inode(numb)
ino_t numb; /* inode number */
{
/* Find the inode specified by the inode and device number.
@@ -197,7 +197,7 @@ ino_t numb; /* inode number */
/*===========================================================================*
* put_inode *
*===========================================================================*/
PUBLIC void put_inode(rip)
void put_inode(rip)
struct inode *rip; /* pointer to inode to be released */
{
/* The caller is no longer using this inode. If no one else is using it either
@@ -238,7 +238,7 @@ struct inode *rip; /* pointer to inode to be released */
/*===========================================================================*
* alloc_inode *
*===========================================================================*/
PUBLIC struct inode *alloc_inode(dev_t dev, mode_t bits)
struct inode *alloc_inode(dev_t dev, mode_t bits)
{
/* Allocate a free inode on 'dev', and return a pointer to it. */
@@ -286,7 +286,7 @@ PUBLIC struct inode *alloc_inode(dev_t dev, mode_t bits)
/*===========================================================================*
* wipe_inode *
*===========================================================================*/
PUBLIC void wipe_inode(rip)
void wipe_inode(rip)
struct inode *rip; /* the inode to be erased */
{
/* Erase some fields in the inode. This function is called from alloc_inode()
@@ -302,7 +302,7 @@ struct inode *rip; /* the inode to be erased */
/*===========================================================================*
* free_inode *
*===========================================================================*/
PUBLIC void free_inode(rip)
void free_inode(rip)
struct inode *rip;
{
/* Return an inode to the pool of unallocated inodes. */
@@ -318,7 +318,7 @@ struct inode *rip;
/*===========================================================================*
* update_times *
*===========================================================================*/
PUBLIC void update_times(rip)
void update_times(rip)
struct inode *rip; /* pointer to inode to be read/written */
{
/* Various system calls are required by the standard to update atime, ctime,

4
servers/pfs/link.c
View File

@@ -6,7 +6,7 @@
/*===========================================================================*
* fs_ftrunc *
*===========================================================================*/
PUBLIC int fs_ftrunc(message *fs_m_in, message *fs_m_out)
int fs_ftrunc(message *fs_m_in, message *fs_m_out)
{
struct inode *rip;
off_t start, end;
@@ -26,7 +26,7 @@ PUBLIC int fs_ftrunc(message *fs_m_in, message *fs_m_out)
/*===========================================================================*
* truncate_inode *
*===========================================================================*/
PUBLIC int truncate_inode(rip, newsize)
int truncate_inode(rip, newsize)
register struct inode *rip; /* pointer to inode to be truncated */
off_t newsize; /* inode must become this size */
{

20
servers/pfs/main.c
View File

@@ -12,17 +12,17 @@
#include "inode.h"
#include "uds.h"
FORWARD void get_work(message *m_in);
static void get_work(message *m_in);
/* 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);
/*===========================================================================*
* main *
*===========================================================================*/
PUBLIC int main(int argc, char *argv[])
int main(int argc, char *argv[])
{
/* This is the main routine of this service. The main loop consists of
* three major activities: getting new work, processing the work, and
@@ -99,7 +99,7 @@ PUBLIC int main(int argc, char *argv[])
/*===========================================================================*
* sef_local_startup *
*===========================================================================*/
PRIVATE void sef_local_startup()
static void sef_local_startup()
{
/* Register init callbacks. */
sef_setcb_init_fresh(sef_cb_init_fresh);
@@ -117,7 +117,7 @@ PRIVATE void sef_local_startup()
/*===========================================================================*
* sef_cb_init_fresh *
*===========================================================================*/
PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
static int sef_cb_init_fresh(int type, sef_init_info_t *info)
{
/* Initialize the pipe file server. */
int i;
@@ -153,7 +153,7 @@ PRIVATE int sef_cb_init_fresh(int type, sef_init_info_t *info)
/*===========================================================================*
* sef_cb_signal_handler *
*===========================================================================*/
PRIVATE void sef_cb_signal_handler(int signo)
static void sef_cb_signal_handler(int signo)
{
/* Only check for termination signal, ignore anything else. */
if (signo != SIGTERM) return;
@@ -165,7 +165,7 @@ PRIVATE void sef_cb_signal_handler(int signo)
/*===========================================================================*
* get_work *
*===========================================================================*/
PRIVATE void get_work(m_in)
static void get_work(m_in)
message *m_in; /* pointer to message */
{
int r, srcok = 0, status;
@@ -188,7 +188,7 @@ message *m_in; /* pointer to message */
/*===========================================================================*
* reply *
*===========================================================================*/
PUBLIC void reply(who, m_out)
void reply(who, m_out)
endpoint_t who;
message *m_out; /* report result */
{

2
servers/pfs/misc.c
View File

@@ -4,7 +4,7 @@
/*===========================================================================*
* fs_sync *
*===========================================================================*/
PUBLIC int fs_sync(message *fs_m_in, message *fs_m_out)
int fs_sync(message *fs_m_in, message *fs_m_out)
{
/* Perform the sync() system call. No-op on this FS. */

2
servers/pfs/mount.c
View File

@@ -5,7 +5,7 @@
/*===========================================================================*
* fs_unmount *
*===========================================================================*/
PUBLIC int fs_unmount(message *fs_m_in, message *fs_m_out)
int fs_unmount(message *fs_m_in, message *fs_m_out)
{
/* Unmount Pipe File Server. */

2
servers/pfs/open.c
View File

@@ -8,7 +8,7 @@
/*===========================================================================*
* fs_newnode *
*===========================================================================*/
PUBLIC int fs_newnode(message *fs_m_in, message *fs_m_out)
int fs_newnode(message *fs_m_in, message *fs_m_out)
{
register int r = OK;
mode_t bits;

2
servers/pfs/read.c
View File

@@ -7,7 +7,7 @@
/*===========================================================================*
* fs_readwrite *
*===========================================================================*/
PUBLIC int fs_readwrite(message *fs_m_in, message *fs_m_out)
int fs_readwrite(message *fs_m_in, message *fs_m_out)
{
int r, rw_flag;
struct buf *bp;

4
servers/pfs/stadir.c
View File

@@ -7,7 +7,7 @@
/*===========================================================================*
* stat_inode *
*===========================================================================*/
PRIVATE int stat_inode(
static int stat_inode(
register struct inode *rip, /* pointer to inode to stat */
endpoint_t who_e, /* Caller endpoint */
cp_grant_id_t gid /* grant for the stat buf */
@@ -57,7 +57,7 @@ PRIVATE int stat_inode(
/*===========================================================================*
* fs_stat *
*===========================================================================*/
PUBLIC int fs_stat(message *fs_m_in, message *fs_m_out)
int fs_stat(message *fs_m_in, message *fs_m_out)
{
register int r; /* return value */
register struct inode *rip; /* target inode */

4
servers/pfs/super.c
View File

@@ -17,7 +17,7 @@
/*===========================================================================*
* alloc_bit *
*===========================================================================*/
PUBLIC bit_t alloc_bit(void)
bit_t alloc_bit(void)
{
/* Allocate a bit from a bit map and return its bit number. */
bitchunk_t *wptr, *wlim;
@@ -55,7 +55,7 @@ PUBLIC bit_t alloc_bit(void)
/*===========================================================================*
* free_bit *
*===========================================================================*/
PUBLIC void free_bit(bit_returned)
void free_bit(bit_returned)
bit_t bit_returned; /* number of bit to insert into the inode map*/
{
bitchunk_t *k, mask;

4
servers/pfs/table.c
View File

@@ -11,7 +11,7 @@
#include "uds.h"
/* File System Handlers (pfs) */
PUBLIC int (*fs_call_vec[])(message *fs_m_in, message *fs_m_out) = {
int (*fs_call_vec[])(message *fs_m_in, message *fs_m_out) = {
no_sys, /* 0 not used */
no_sys, /* 1 */
@@ -49,7 +49,7 @@ PUBLIC int (*fs_call_vec[])(message *fs_m_in, message *fs_m_out) = {
};
/* Device Handlers (/dev/uds) */
PUBLIC int (*dev_call_vec[])(message *dev_m_in, message *dev_m_out) = {
int (*dev_call_vec[])(message *dev_m_in, message *dev_m_out) = {
uds_cancel, /* 0 CANCEL */
no_sys, /* 1 */

58
servers/pfs/uds.c
View File

@@ -44,7 +44,7 @@
uds_fd_t uds_fd_table[NR_FDS];
/* initialize the descriptor table */
PUBLIC void uds_init(void)
void uds_init(void)
{
/*
* Setting everything to NULL implicitly sets the
@@ -54,7 +54,7 @@ PUBLIC void uds_init(void)
}
/* check the permissions of a socket file */
PRIVATE int check_perms(int minor, struct sockaddr_un *addr)
static int check_perms(int minor, struct sockaddr_un *addr)
{
int rc;
message vfs_m;
@@ -88,7 +88,7 @@ PRIVATE int check_perms(int minor, struct sockaddr_un *addr)
return vfs_m.m_type; /* return reply code OK, ELOOP, etc. */
}
PRIVATE filp_id_t verify_fd(endpoint_t ep, int fd)
static filp_id_t verify_fd(endpoint_t ep, int fd)
{
int rc;
message vfs_m;
@@ -119,7 +119,7 @@ PRIVATE filp_id_t verify_fd(endpoint_t ep, int fd)
return vfs_m.ADDRESS;
}
PRIVATE int set_filp(filp_id_t sfilp)
static int set_filp(filp_id_t sfilp)
{
int rc;
message vfs_m;
@@ -147,7 +147,7 @@ PRIVATE int set_filp(filp_id_t sfilp)
return vfs_m.m_type; /* return reply code OK, ELOOP, etc. */
}
PRIVATE int copy_filp(endpoint_t to_ep, filp_id_t cfilp)
static int copy_filp(endpoint_t to_ep, filp_id_t cfilp)
{
int rc;
message vfs_m;
@@ -177,7 +177,7 @@ PRIVATE int copy_filp(endpoint_t to_ep, filp_id_t cfilp)
return vfs_m.m_type;
}
PRIVATE int put_filp(filp_id_t pfilp)
static int put_filp(filp_id_t pfilp)
{
int rc;
message vfs_m;
@@ -205,7 +205,7 @@ PRIVATE int put_filp(filp_id_t pfilp)
return vfs_m.m_type; /* return reply code OK, ELOOP, etc. */
}
PRIVATE int cancel_fd(endpoint_t ep, int fd)
static int cancel_fd(endpoint_t ep, int fd)
{
int rc;
message vfs_m;
@@ -234,7 +234,7 @@ PRIVATE int cancel_fd(endpoint_t ep, int fd)
return vfs_m.m_type; /* return reply code OK, ELOOP, etc. */
}
PUBLIC int perform_connection(message *dev_m_in, message *dev_m_out,
int perform_connection(message *dev_m_in, message *dev_m_out,
struct sockaddr_un *addr, int minorx, int minory)
{
/* there are several places were a connection is established. */
@@ -271,7 +271,7 @@ PUBLIC int perform_connection(message *dev_m_in, message *dev_m_out,
}
PUBLIC int do_accept(message *dev_m_in, message *dev_m_out)
int do_accept(message *dev_m_in, message *dev_m_out)
{
int minor;
int minorparent; /* minor number of parent (server) */
@@ -397,7 +397,7 @@ PUBLIC int do_accept(message *dev_m_in, message *dev_m_out)
return OK;
}
PUBLIC int do_connect(message *dev_m_in, message *dev_m_out)
int do_connect(message *dev_m_in, message *dev_m_out)
{
int minor;
struct sockaddr_un addr;
@@ -556,7 +556,7 @@ PUBLIC int do_connect(message *dev_m_in, message *dev_m_out)
return SUSPEND;
}
PUBLIC int do_listen(message *dev_m_in, message *dev_m_out)
int do_listen(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;
@@ -636,7 +636,7 @@ PUBLIC int do_listen(message *dev_m_in, message *dev_m_out)
return OK;
}
PUBLIC int do_socket(message *dev_m_in, message *dev_m_out)
int do_socket(message *dev_m_in, message *dev_m_out)
{
int rc;
int minor;
@@ -688,7 +688,7 @@ PUBLIC int do_socket(message *dev_m_in, message *dev_m_out)
}
}
PUBLIC int do_bind(message *dev_m_in, message *dev_m_out)
int do_bind(message *dev_m_in, message *dev_m_out)
{
int minor;
struct sockaddr_un addr;
@@ -756,7 +756,7 @@ PUBLIC int do_bind(message *dev_m_in, message *dev_m_out)
return OK;
}
PUBLIC int do_getsockname(message *dev_m_in, message *dev_m_out)
int do_getsockname(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;
@@ -782,7 +782,7 @@ PUBLIC int do_getsockname(message *dev_m_in, message *dev_m_out)
return rc ? EIO : OK;
}
PUBLIC int do_getpeername(message *dev_m_in, message *dev_m_out)
int do_getpeername(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;
@@ -819,7 +819,7 @@ PUBLIC int do_getpeername(message *dev_m_in, message *dev_m_out)
}
}
PUBLIC int do_shutdown(message *dev_m_in, message *dev_m_out)
int do_shutdown(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc, how;
@@ -882,7 +882,7 @@ PUBLIC int do_shutdown(message *dev_m_in, message *dev_m_out)
return OK;
}
PUBLIC int do_socketpair_old(message *dev_m_in, message *dev_m_out)
int do_socketpair_old(message *dev_m_in, message *dev_m_out)
{
int rc;
short minorin;
@@ -929,7 +929,7 @@ PUBLIC int do_socketpair_old(message *dev_m_in, message *dev_m_out)
return perform_connection(dev_m_in, dev_m_out, &addr, minorx, minory);
}
PUBLIC int do_socketpair(message *dev_m_in, message *dev_m_out)
int do_socketpair(message *dev_m_in, message *dev_m_out)
{
int rc;
dev_t minorin;
@@ -976,7 +976,7 @@ PUBLIC int do_socketpair(message *dev_m_in, message *dev_m_out)
return perform_connection(dev_m_in, dev_m_out, &addr, minorx, minory);
}
PUBLIC int do_getsockopt_sotype(message *dev_m_in, message *dev_m_out)
int do_getsockopt_sotype(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;
@@ -1004,7 +1004,7 @@ PUBLIC int do_getsockopt_sotype(message *dev_m_in, message *dev_m_out)
return rc ? EIO : OK;
}
PUBLIC int do_getsockopt_peercred(message *dev_m_in, message *dev_m_out)
int do_getsockopt_peercred(message *dev_m_in, message *dev_m_out)
{
int minor;
int peer_minor;
@@ -1045,7 +1045,7 @@ PUBLIC int do_getsockopt_peercred(message *dev_m_in, message *dev_m_out)
return rc ? EIO : OK;
}
PUBLIC int do_getsockopt_peercred_old(message *dev_m_in, message *dev_m_out)
int do_getsockopt_peercred_old(message *dev_m_in, message *dev_m_out)
{
int minor;
int peer_minor;
@@ -1204,7 +1204,7 @@ int do_setsockopt_rcvbuf(message *dev_m_in, message *dev_m_out)
}
PUBLIC int do_sendto(message *dev_m_in, message *dev_m_out)
int do_sendto(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;
@@ -1248,7 +1248,7 @@ PUBLIC int do_sendto(message *dev_m_in, message *dev_m_out)
return OK;
}
PUBLIC int do_recvfrom(message *dev_m_in, message *dev_m_out)
int do_recvfrom(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;
@@ -1327,7 +1327,7 @@ int msg_control_read(struct msg_control *msg_ctrl, struct ancillary *data,
return OK;
}
PRIVATE int send_fds(int minor, struct ancillary *data)
static int send_fds(int minor, struct ancillary *data)
{
int rc, i, j;
@@ -1361,7 +1361,7 @@ PRIVATE int send_fds(int minor, struct ancillary *data)
return OK;
}
PUBLIC int clear_fds(int minor, struct ancillary *data)
int clear_fds(int minor, struct ancillary *data)
{
/* This function calls put_filp() for all of the FDs in data.
* This is used when a Unix Domain Socket is closed and there
@@ -1390,7 +1390,7 @@ PUBLIC int clear_fds(int minor, struct ancillary *data)
return OK;
}
PRIVATE int recv_fds(int minor, struct ancillary *data,
static int recv_fds(int minor, struct ancillary *data,
struct msg_control *msg_ctrl)
{
int rc, i, j;
@@ -1446,7 +1446,7 @@ PRIVATE int recv_fds(int minor, struct ancillary *data,
return OK;
}
PRIVATE int recv_cred(int minor, struct ancillary *data,
static int recv_cred(int minor, struct ancillary *data,
struct msg_control *msg_ctrl)
{
struct msghdr msghdr;
@@ -1474,7 +1474,7 @@ PRIVATE int recv_cred(int minor, struct ancillary *data,
return OK;
}
PUBLIC int do_sendmsg(message *dev_m_in, message *dev_m_out)
int do_sendmsg(message *dev_m_in, message *dev_m_out)
{
int minor, peer, rc, i;
struct msg_control msg_ctrl;
@@ -1548,7 +1548,7 @@ PUBLIC int do_sendmsg(message *dev_m_in, message *dev_m_out)
return send_fds(minor, &uds_fd_table[peer].ancillary_data);
}
PUBLIC int do_recvmsg(message *dev_m_in, message *dev_m_out)
int do_recvmsg(message *dev_m_in, message *dev_m_out)
{
int minor;
int rc;

4
servers/pfs/utility.c
View File

@@ -4,7 +4,7 @@
/*===========================================================================*
* no_sys *
*===========================================================================*/
PUBLIC int no_sys(message *pfs_m_in, message *pfs_m_out)
int no_sys(message *pfs_m_in, message *pfs_m_out)
{
/* Somebody has used an illegal system call number */
printf("no_sys: invalid call 0x%x to pfs\n", req_nr);
@@ -15,7 +15,7 @@ PUBLIC int no_sys(message *pfs_m_in, message *pfs_m_out)
/*===========================================================================*
* clock_time *
*===========================================================================*/
PUBLIC time_t clock_time()
time_t clock_time()
{
/* This routine returns the time in seconds since 1.1.1970. MINIX is an
* astrophysically naive system that assumes the earth rotates at a constant